{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "fa7e3e52",
   "metadata": {},
   "source": [
    "# ResNet50图像分类\n",
    "\n",
    "\n",
    "图像分类是最基础的计算机视觉应用，属于有监督学习类别，如给定一张图像(猫、狗、飞机、汽车等等)，判断图像所属的类别。本案例将介绍使用ResNet50网络对CIFAR-10数据集进行分类。\n",
    "\n",
    "## ResNet网络介绍\n",
    "\n",
    "ResNet50网络是2015年由微软实验室的何恺明提出，获得ILSVRC2015图像分类竞赛第一名。在ResNet网络提出之前，传统的卷积神经网络都是将一系列的卷积层和池化层堆叠得到的，但当网络堆叠到一定深度时，就会出现退化问题。下图是在CIFAR-10数据集上使用56层网络与20层网络训练误差和测试误差图，由图中数据可以看出，56层网络比20层网络训练误差和测试误差更大，随着网络的加深，其误差并没有如预想的一样减小。\n",
    "\n",
    "![resnet-1](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r2.3.0/tutorials/application/source_zh_cn/cv/images/resnet_1.png)\n",
    "\n",
    "ResNet网络提出了残差网络结构(Residual Network)来减轻退化问题，使用ResNet网络可以实现搭建较深的网络结构（突破1000层）。论文中使用ResNet网络在CIFAR-10数据集上的训练误差与测试误差图如下图所示，图中虚线表示训练误差，实线表示测试误差。由图中数据可以看出，ResNet网络层数越深，其训练误差和测试误差越小。\n",
    "\n",
    "![resnet-4](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r2.3.0/tutorials/application/source_zh_cn/cv/images/resnet_4.png)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea0c374d-51fe-4ddd-b8de-1a66a8150de8",
   "metadata": {},
   "source": [
    "## 环境准备\n",
    "\n",
    "开发者拿到香橙派开发板后，首先需要进行硬件资源确认，镜像烧录及CANN和MindSpore版本的升级，才可运行该案例，具体如下：\n",
    "\n",
    "- 硬件： 香橙派AIpro 8G 8T开发板\n",
    "- 镜像： 香橙派官网ubuntu镜像\n",
    "- CANN：8.1.RC1\n",
    "- MindSpore： 2.6.0\n",
    "\n",
    "### 镜像烧录\n",
    "\n",
    "运行该案例需要烧录香橙派官网ubuntu镜像，烧录流程参考[昇思MindSpore官网--香橙派开发专区--环境搭建指南--镜像烧录](https://www.mindspore.cn/tutorials/zh-CN/r2.6.0/orange_pi/environment_setup.html#1-%E9%95%9C%E5%83%8F%E7%83%A7%E5%BD%95%E4%BB%A5windows%E7%B3%BB%E7%BB%9F%E4%B8%BA%E4%BE%8B)章节。\n",
    "\n",
    "### CANN升级\n",
    "\n",
    "CANN升级参考[昇思MindSpore官网--香橙派开发专区--环境搭建指南--CANN升级](https://www.mindspore.cn/tutorials/zh-CN/r2.6.0/orange_pi/environment_setup.html#3-cann%E5%8D%87%E7%BA%A7)章节。\n",
    "\n",
    "### MindSpore升级\n",
    "\n",
    "MindSpore升级参考[昇思MindSpore官网--香橙派开发专区--环境搭建指南--MindSpore升级](https://www.mindspore.cn/tutorials/zh-CN/r2.6.0/orange_pi/environment_setup.html#4-mindspore%E5%8D%87%E7%BA%A7)章节。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a987ee48",
   "metadata": {},
   "source": [
    "## 数据集准备与加载\n",
    "\n",
    "[CIFAR-10数据集](http://www.cs.toronto.edu/~kriz/cifar.html)共有60000张32*32的彩色图像，分为10个类别，每类有6000张图，数据集一共有50000张训练图片和10000张评估图片。首先，如下示例使用`download`接口下载并解压，目前仅支持解析二进制版本的CIFAR-10文件（CIFAR-10 binary version）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "1f9b81fb",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-23T16:12:16.826382Z",
     "start_time": "2024-07-23T16:12:09.656929Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading data from https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/datasets/cifar-10-binary.tar.gz (162.2 MB)\n",
      "\n",
      "file_sizes: 100%|████████████████████████████| 170M/170M [00:12<00:00, 13.2MB/s]\n",
      "Extracting tar.gz file...\n",
      "Successfully downloaded / unzipped to ./datasets-cifar10-bin\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'./datasets-cifar10-bin'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from download import download\n",
    "\n",
    "url = \"https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/datasets/cifar-10-binary.tar.gz\"\n",
    "\n",
    "download(url, \"./datasets-cifar10-bin\", kind=\"tar.gz\", replace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e9020ba",
   "metadata": {},
   "source": [
    "下载后的数据集目录结构如下：\n",
    "\n",
    "```text\n",
    "datasets-cifar10-bin/cifar-10-batches-bin\n",
    "├── batches.meta.text\n",
    "├── data_batch_1.bin\n",
    "├── data_batch_2.bin\n",
    "├── data_batch_3.bin\n",
    "├── data_batch_4.bin\n",
    "├── data_batch_5.bin\n",
    "├── readme.html\n",
    "└── test_batch.bin\n",
    "\n",
    "```\n",
    "\n",
    "然后，使用`mindspore.dataset.Cifar10Dataset`接口来加载数据集，并进行相关图像增强操作。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "df7fb621",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-23T16:13:58.251634Z",
     "start_time": "2024-07-23T16:13:56.030465Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/miniconda3/lib/python3.9/site-packages/numpy/core/getlimits.py:518: UserWarning: The value of the smallest subnormal for <class 'numpy.float64'> type is zero.\n",
      "  setattr(self, word, getattr(machar, word).flat[0])\n",
      "/usr/local/miniconda3/lib/python3.9/site-packages/numpy/core/getlimits.py:89: UserWarning: The value of the smallest subnormal for <class 'numpy.float64'> type is zero.\n",
      "  return self._float_to_str(self.smallest_subnormal)\n",
      "/usr/local/miniconda3/lib/python3.9/site-packages/numpy/core/getlimits.py:518: UserWarning: The value of the smallest subnormal for <class 'numpy.float32'> type is zero.\n",
      "  setattr(self, word, getattr(machar, word).flat[0])\n",
      "/usr/local/miniconda3/lib/python3.9/site-packages/numpy/core/getlimits.py:89: UserWarning: The value of the smallest subnormal for <class 'numpy.float32'> type is zero.\n",
      "  return self._float_to_str(self.smallest_subnormal)\n"
     ]
    }
   ],
   "source": [
    "import mindspore as ms\n",
    "import mindspore.dataset as ds\n",
    "import mindspore.dataset.vision as vision\n",
    "import mindspore.dataset.transforms as transforms\n",
    "from mindspore import dtype as mstype\n",
    "\n",
    "data_dir = \"./datasets-cifar10-bin/cifar-10-batches-bin\"  # 数据集根目录\n",
    "batch_size = 4  # 批量大小\n",
    "image_size = 32  # 训练图像空间大小\n",
    "workers = 4\n",
    "num_classes = 10  # 分类数量\n",
    "\n",
    "\n",
    "def create_dataset_cifar10(dataset_dir, usage, resize, batch_size, workers):\n",
    "\n",
    "    data_set = ds.Cifar10Dataset(dataset_dir=dataset_dir,\n",
    "                                 usage=usage,\n",
    "                                 num_parallel_workers=workers,\n",
    "                                 num_samples=32,\n",
    "                                 shuffle=True)\n",
    "\n",
    "    trans = [\n",
    "        vision.Resize(resize),\n",
    "        vision.Rescale(1.0 / 255.0, 0.0),\n",
    "        vision.Normalize([0.4914, 0.4822, 0.4465], [0.2023, 0.1994, 0.2010]),\n",
    "        vision.HWC2CHW(),\n",
    "        transforms.TypeCast(mstype.float16)\n",
    "    ]\n",
    "\n",
    "    \n",
    "    target_trans = transforms.TypeCast(mstype.int32)\n",
    "\n",
    "    # 数据映射操作\n",
    "    data_set = data_set.map(operations=trans,\n",
    "                            input_columns='image',\n",
    "                            num_parallel_workers=workers)\n",
    "\n",
    "    data_set = data_set.map(operations=target_trans,\n",
    "                            input_columns='label',\n",
    "                            num_parallel_workers=workers)\n",
    "\n",
    "    # 批量操作\n",
    "    data_set = data_set.batch(batch_size)\n",
    "\n",
    "    return data_set\n",
    "\n",
    "\n",
    "# 获取处理后的验证数据集\n",
    "dataset_val = create_dataset_cifar10(dataset_dir=data_dir,\n",
    "                                     usage=\"test\",\n",
    "                                     resize=image_size,\n",
    "                                     batch_size=batch_size,\n",
    "                                     workers=workers)\n",
    "step_size_val = dataset_val.get_dataset_size()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21e86f95",
   "metadata": {},
   "source": [
    "对CIFAR-10验证数据集进行可视化。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "8b5ceed8bd98f938",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-23T16:14:05.443445Z",
     "start_time": "2024-07-23T16:14:05.190788Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Image shape: (4, 3, 32, 32), Label shape: (4,)\n",
      "Labels: [7 5 2 4]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "data_iter = next(dataset_val.create_dict_iterator())\n",
    "\n",
    "images = data_iter[\"image\"].asnumpy()\n",
    "labels = data_iter[\"label\"].asnumpy()\n",
    "print(f\"Image shape: {images.shape}, Label shape: {labels.shape}\")\n",
    "\n",
    "# 验证数据集中，前四张图片所对应的标签\n",
    "print(f\"Labels: {labels[:4]}\")\n",
    "\n",
    "classes = []\n",
    "\n",
    "with open(data_dir + \"/batches.meta.txt\", \"r\") as f:\n",
    "    for line in f:\n",
    "        line = line.rstrip()\n",
    "        if line:\n",
    "            classes.append(line)\n",
    "\n",
    "# 验证数据集的前四张图片\n",
    "plt.figure()\n",
    "for i in range(4):\n",
    "    plt.subplot(2, 2, i + 1)\n",
    "    image_trans = np.transpose(images[i], (1, 2, 0))\n",
    "    mean = np.array([0.4914, 0.4822, 0.4465])\n",
    "    std = np.array([0.2023, 0.1994, 0.2010])\n",
    "    image_trans = std * image_trans + mean\n",
    "    image_trans = np.clip(image_trans, 0, 1)\n",
    "    plt.title(f\"{classes[labels[i]]}\")\n",
    "    plt.imshow(image_trans)\n",
    "    plt.axis(\"off\")\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76c96f76",
   "metadata": {},
   "source": [
    "## 网络构建\n",
    "\n",
    "残差网络结构(Residual Network)是ResNet网络的主要亮点，ResNet使用残差网络结构后可有效地减轻退化问题，实现更深的网络结构设计，提高网络的训练精度。本节首先讲述如何构建残差网络结构，然后通过堆叠残差网络来构建ResNet50网络。\n",
    "\n",
    "### 构建残差网络结构\n",
    "\n",
    "残差网络结构图如下图所示，残差网络由两个分支构成：一个主分支，一个shortcuts（图中弧线表示）。主分支通过堆叠一系列的卷积操作得到，shortcuts从输入直接到输出，主分支输出的特征矩阵$F(x)$加上shortcuts输出的特征矩阵$x$得到$F(x)+x$，通过Relu激活函数后即为残差网络最后的输出。\n",
    "\n",
    "![residual](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r2.3.0/tutorials/application/source_zh_cn/cv/images/resnet_3.png)\n",
    "\n",
    "残差网络结构主要由两种，一种是Building Block，适用于较浅的ResNet网络，如ResNet18和ResNet34；另一种是Bottleneck，适用于层数较深的ResNet网络，如ResNet50、ResNet101和ResNet152。\n",
    "\n",
    "#### Building Block\n",
    "\n",
    "Building Block结构图如下图所示，主分支有两层卷积网络结构：\n",
    "\n",
    "+ 主分支第一层网络以输入channel为64为例，首先通过一个$3\\times3$的卷积层，然后通过Batch Normalization层，最后通过Relu激活函数层，输出channel为64；\n",
    "+ 主分支第二层网络的输入channel为64，首先通过一个$3\\times3$的卷积层，然后通过Batch Normalization层，输出channel为64。\n",
    "\n",
    "最后将主分支输出的特征矩阵与shortcuts输出的特征矩阵相加，通过Relu激活函数即为Building Block最后的输出。\n",
    "\n",
    "![building-block-5](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r2.3.0/tutorials/application/source_zh_cn/cv/images/resnet_5.png)\n",
    "\n",
    "主分支与shortcuts输出的特征矩阵相加时，需要保证主分支与shortcuts输出的特征矩阵shape相同。如果主分支与shortcuts输出的特征矩阵shape不相同，如输出channel是输入channel的一倍时，shortcuts上需要使用数量与输出channel相等，大小为$1\\times1$的卷积核进行卷积操作；若输出的图像较输入图像缩小一倍，则要设置shortcuts中卷积操作中的`stride`为2，主分支第一层卷积操作的`stride`也需设置为2。\n",
    "\n",
    "如下代码定义`ResidualBlockBase`类实现Building Block结构。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c7ac0e2d",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-23T16:14:10.014666Z",
     "start_time": "2024-07-23T16:14:09.995148Z"
    }
   },
   "outputs": [],
   "source": [
    "from typing import Type, Union, List, Optional\n",
    "import mindspore.nn as nn\n",
    "from mindspore.common.initializer import Normal\n",
    "from mindspore import mint\n",
    "\n",
    "\n",
    "# 初始化卷积层与BatchNorm的参数\n",
    "weight_init = Normal(mean=0, sigma=0.02)\n",
    "gamma_init = Normal(mean=1, sigma=0.02)\n",
    "\n",
    "class ResidualBlockBase(nn.Cell):\n",
    "    expansion: int = 1  # 最后一个卷积核数量与第一个卷积核数量相等\n",
    "\n",
    "    def __init__(self, in_channel: int, out_channel: int,\n",
    "                 stride: int = 1, norm: Optional[nn.Cell] = None,\n",
    "                 down_sample: Optional[nn.Cell] = None) -> None:\n",
    "        super(ResidualBlockBase, self).__init__()\n",
    "        if not norm:\n",
    "            self.norm = nn.BatchNorm2d(out_channel, dtype=mstype.float16)\n",
    "        else:\n",
    "            self.norm = norm\n",
    "\n",
    "        self.conv1 = nn.Conv2d(in_channel, out_channel,\n",
    "                               kernel_size=3, stride=stride,\n",
    "                               weight_init=weight_init, dtype=mstype.float16)\n",
    "        self.conv2 = nn.Conv2d(in_channel, out_channel,\n",
    "                               kernel_size=3, weight_init=weight_init, dtype=mstype.float16)\n",
    "        self.relu = mint.nn.ReLU()\n",
    "        self.down_sample = down_sample\n",
    "\n",
    "    def construct(self, x):\n",
    "        \"\"\"ResidualBlockBase construct.\"\"\"\n",
    "        identity = x  # shortcuts分支\n",
    "\n",
    "        out = self.conv1(x)  # 主分支第一层：3*3卷积层\n",
    "        out = self.norm(out)\n",
    "        out = self.relu(out)\n",
    "        out = self.conv2(out)  # 主分支第二层：3*3卷积层\n",
    "        out = self.norm(out)\n",
    "\n",
    "        if self.down_sample is not None:\n",
    "            identity = self.down_sample(x)\n",
    "        out += identity  # 输出为主分支与shortcuts之和\n",
    "        out = self.relu(out)\n",
    "\n",
    "        return out"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aaa15d3c",
   "metadata": {},
   "source": [
    "#### Bottleneck\n",
    "\n",
    "Bottleneck结构图如下图所示，在输入相同的情况下Bottleneck结构相对Building Block结构的参数数量更少，更适合层数较深的网络，ResNet50使用的残差结构就是Bottleneck。该结构的主分支有三层卷积结构，分别为$1\\times1$的卷积层、$3\\times3$卷积层和$1\\times1$的卷积层，其中$1\\times1$的卷积层分别起降维和升维的作用。\n",
    "\n",
    "+ 主分支第一层网络以输入channel为256为例，首先通过数量为64，大小为$1\\times1$的卷积核进行降维，然后通过Batch Normalization层，最后通过Relu激活函数层，其输出channel为64；\n",
    "+ 主分支第二层网络通过数量为64，大小为$3\\times3$的卷积核提取特征，然后通过Batch Normalization层，最后通过Relu激活函数层，其输出channel为64；\n",
    "+ 主分支第三层通过数量为256，大小$1\\times1$的卷积核进行升维，然后通过Batch Normalization层，其输出channel为256。\n",
    "\n",
    "最后将主分支输出的特征矩阵与shortcuts输出的特征矩阵相加，通过Relu激活函数即为Bottleneck最后的输出。\n",
    "\n",
    "![building-block-6](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r2.3.0/tutorials/application/source_zh_cn/cv/images/resnet_6.png)\n",
    "\n",
    "主分支与shortcuts输出的特征矩阵相加时，需要保证主分支与shortcuts输出的特征矩阵shape相同。如果主分支与shortcuts输出的特征矩阵shape不相同，如输出channel是输入channel的一倍时，shortcuts上需要使用数量与输出channel相等，大小为$1\\times1$的卷积核进行卷积操作；若输出的图像较输入图像缩小一倍，则要设置shortcuts中卷积操作中的`stride`为2，主分支第二层卷积操作的`stride`也需设置为2。\n",
    "\n",
    "如下代码定义`ResidualBlock`类实现Bottleneck结构。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "0d46f98e",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-23T16:14:12.633224Z",
     "start_time": "2024-07-23T16:14:12.603213Z"
    }
   },
   "outputs": [],
   "source": [
    "class ResidualBlock(nn.Cell):\n",
    "    expansion = 4  # 最后一个卷积核的数量是第一个卷积核数量的4倍\n",
    "\n",
    "    def __init__(self, in_channel: int, out_channel: int,\n",
    "                 stride: int = 1, down_sample: Optional[nn.Cell] = None) -> None:\n",
    "        super(ResidualBlock, self).__init__()\n",
    "\n",
    "        self.conv1 = nn.Conv2d(in_channel, out_channel,\n",
    "                               kernel_size=1, weight_init=weight_init, dtype=mstype.float16)\n",
    "        self.norm1 = nn.BatchNorm2d(out_channel, dtype=mstype.float16)\n",
    "        self.conv2 = nn.Conv2d(out_channel, out_channel,\n",
    "                               kernel_size=3, stride=stride,\n",
    "                               weight_init=weight_init, dtype=mstype.float16)\n",
    "        self.norm2 = nn.BatchNorm2d(out_channel, dtype=mstype.float16)\n",
    "        self.conv3 = nn.Conv2d(out_channel, out_channel * self.expansion,\n",
    "                               kernel_size=1, weight_init=weight_init, dtype=mstype.float16)\n",
    "        self.norm3 = nn.BatchNorm2d(out_channel * self.expansion, dtype=mstype.float16)\n",
    "\n",
    "        self.relu = mint.nn.ReLU()\n",
    "        self.down_sample = down_sample\n",
    "\n",
    "    def construct(self, x):\n",
    "\n",
    "        identity = x  # shortscuts分支\n",
    "\n",
    "        out = self.conv1(x)  # 主分支第一层：1*1卷积层\n",
    "        out = self.norm1(out)\n",
    "        out = self.relu(out)\n",
    "        out = self.conv2(out)  # 主分支第二层：3*3卷积层\n",
    "        out = self.norm2(out)\n",
    "        out = self.relu(out)\n",
    "        out = self.conv3(out)  # 主分支第三层：1*1卷积层\n",
    "        out = self.norm3(out)\n",
    "\n",
    "        if self.down_sample is not None:\n",
    "            identity = self.down_sample(x)\n",
    "\n",
    "        out += identity  # 输出为主分支与shortcuts之和\n",
    "        out = self.relu(out)\n",
    "\n",
    "        return out"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1d8dfc9",
   "metadata": {},
   "source": [
    "#### 构建ResNet50网络\n",
    "\n",
    "ResNet网络层结构如下图所示，以输入彩色图像$224\\times224$为例，首先通过数量64，卷积核大小为$7\\times7$，stride为2的卷积层conv1，该层输出图片大小为$112\\times112$，输出channel为64；然后通过一个$3\\times3$的最大下采样池化层，该层输出图片大小为$56\\times56$，输出channel为64；再堆叠4个残差网络块（conv2_x、conv3_x、conv4_x和conv5_x），此时输出图片大小为$7\\times7$，输出channel为2048；最后通过一个平均池化层、全连接层和softmax，得到分类概率。\n",
    "\n",
    "![resnet-layer](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r2.3.0/tutorials/application/source_zh_cn/cv/images/resnet_2.png)\n",
    "\n",
    "对于每个残差网络块，以ResNet50网络中的conv2_x为例，其由3个Bottleneck结构堆叠而成，每个Bottleneck输入的channel为64，输出channel为256。\n",
    "\n",
    "如下示例定义`make_layer`实现残差块的构建，其参数如下所示:\n",
    "\n",
    "+ `last_out_channel`：上一个残差网络输出的通道数。\n",
    "+ `block`：残差网络的类别，分别为`ResidualBlockBase`和`ResidualBlock`。\n",
    "+ `channel`：残差网络块1*1卷积层的输出通道数\n",
    "+ `block_nums`：残差网络块堆叠的个数。\n",
    "+ `stride`：卷积移动的步幅。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "3dfa40a1",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-23T16:14:16.548310Z",
     "start_time": "2024-07-23T16:14:16.518299Z"
    }
   },
   "outputs": [],
   "source": [
    "def make_layer(last_out_channel, block: Type[Union[ResidualBlockBase, ResidualBlock]],\n",
    "               channel: int, block_nums: int, stride: int = 1):\n",
    "    down_sample = None  # shortcuts分支\n",
    "\n",
    "    if stride != 1 or last_out_channel != channel * block.expansion:\n",
    "\n",
    "        down_sample = nn.SequentialCell([\n",
    "            nn.Conv2d(last_out_channel, channel * block.expansion,\n",
    "                      kernel_size=1, stride=stride, weight_init=weight_init, dtype=mstype.float16),\n",
    "            nn.BatchNorm2d(channel * block.expansion, gamma_init=gamma_init, dtype=mstype.float16)\n",
    "        ])\n",
    "\n",
    "    layers = []\n",
    "    layers.append(block(last_out_channel, channel, stride=stride, down_sample=down_sample))\n",
    "\n",
    "    in_channel = channel * block.expansion\n",
    "    # 堆叠残差网络\n",
    "    for _ in range(1, block_nums):\n",
    "\n",
    "        layers.append(block(in_channel, channel))\n",
    "\n",
    "    return nn.SequentialCell(layers)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67dae353",
   "metadata": {},
   "source": [
    "ResNet50网络共有5个卷积结构，一个平均池化层，一个全连接层，以CIFAR-10数据集为例：\n",
    "\n",
    "+ **conv1**：输入图片大小为$32\\times32$，输入channel为3。首先经过一个卷积核数量为64，卷积核大小为$7\\times7$，stride为2的卷积层；然后通过一个Batch Normalization层；最后通过ReLu激活函数。该层输出feature map大小为$16\\times16$，输出channel为64。\n",
    "+ **conv2_x**：输入feature map大小为$16\\times16$，输入channel为64。首先经过一个卷积核大小为$3\\times3$，stride为2的最大下采样池化操作；然后堆叠3个$[1\\times1，64；3\\times3，64；1\\times1，256]$结构的Bottleneck。该层输出feature map大小为$8\\times8$，输出channel为256。\n",
    "+ **conv3_x**：输入feature map大小为$8\\times8$，输入channel为256。该层堆叠4个[1×1，128；3×3，128；1×1，512]结构的Bottleneck。该层输出feature map大小为$4\\times4$，输出channel为512。\n",
    "+ **conv4_x**：输入feature map大小为$4\\times4$，输入channel为512。该层堆叠6个[1×1，256；3×3，256；1×1，1024]结构的Bottleneck。该层输出feature map大小为$2\\times2$，输出channel为1024。\n",
    "+ **conv5_x**：输入feature map大小为$2\\times2$，输入channel为1024。该层堆叠3个[1×1，512；3×3，512；1×1，2048]结构的Bottleneck。该层输出feature map大小为$1\\times1$，输出channel为2048。\n",
    "+ **average pool & fc**：输入channel为2048，输出channel为分类的类别数。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "1ebef3d0",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-23T16:14:18.861501Z",
     "start_time": "2024-07-23T16:14:18.831268Z"
    }
   },
   "outputs": [],
   "source": [
    "class ResNet(nn.Cell):\n",
    "    def __init__(self, block: Type[Union[ResidualBlockBase, ResidualBlock]],\n",
    "                 layer_nums: List[int], num_classes: int, input_channel: int) -> None:\n",
    "        super(ResNet, self).__init__()\n",
    "\n",
    "        self.relu = mint.nn.ReLU()\n",
    "        # 第一个卷积层，输入channel为3（彩色图像），输出channel为64\n",
    "        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, weight_init=weight_init, dtype=mstype.float16)\n",
    "        self.norm = nn.BatchNorm2d(64, dtype=mstype.float16)\n",
    "        # 最大池化层，缩小图片的尺寸\n",
    "        self.max_pool = nn.MaxPool2d(kernel_size=3, stride=2, pad_mode='same')\n",
    "        # 各个残差网络结构块定义\n",
    "        self.layer1 = make_layer(64, block, 64, layer_nums[0])\n",
    "        self.layer2 = make_layer(64 * block.expansion, block, 128, layer_nums[1], stride=2)\n",
    "        self.layer3 = make_layer(128 * block.expansion, block, 256, layer_nums[2], stride=2)\n",
    "        self.layer4 = make_layer(256 * block.expansion, block, 512, layer_nums[3], stride=2)\n",
    "        # 平均池化层\n",
    "        self.avg_pool = mint.nn.AvgPool2d(kernel_size=1)\n",
    "        # 全连接层\n",
    "        self.fc = mint.nn.Linear(in_features=input_channel, out_features=num_classes, dtype=mstype.float16)\n",
    "\n",
    "    def construct(self, x):\n",
    "\n",
    "        x = self.conv1(x)\n",
    "        x = self.norm(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.max_pool(x)\n",
    "\n",
    "        x = self.layer1(x)\n",
    "        x = self.layer2(x)\n",
    "        x = self.layer3(x)\n",
    "        x = self.layer4(x)\n",
    "\n",
    "        x = self.avg_pool(x)\n",
    "        x = mint.flatten(x, 1, -1)\n",
    "        x = self.fc(x)\n",
    "\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6cfab27",
   "metadata": {},
   "source": [
    "## 权重加载\n",
    "加载保存的权重分为两步：\n",
    "\n",
    "1. 重新实例化模型对象，构造模型。\n",
    "2. 加载模型参数，并将其加载至模型上。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "23e70022",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading data from https://cdn.modelers.cn/lfs/2f/ee/6cb667f33597bad87722cf530459f871df94109c84b5a6851960f6cc93d6?response-content-disposition=attachment%3B+filename%3D%22resnet50-best.ckpt%22&AWSAccessKeyId=TPZ2BP69IUCP9B8KNS3L&Expires=1752384507&Signature=%2FQEm2MrDWDxYjaw86qKesNv67KA%3D (90.0 MB)\n",
      "\n",
      "file_sizes: 100%|██████████████████████████| 94.3M/94.3M [00:07<00:00, 12.8MB/s]\n",
      "Successfully downloaded file to ./resnet50-best.ckpt\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.454.053 [mindspore/train/serialization.py:319] The type of conv1.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.457.707 [mindspore/train/serialization.py:319] The type of norm.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.461.164 [mindspore/train/serialization.py:319] The type of norm.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.464.205 [mindspore/train/serialization.py:319] The type of norm.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.467.202 [mindspore/train/serialization.py:319] The type of norm.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.470.340 [mindspore/train/serialization.py:319] The type of layer1.0.conv1.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.473.345 [mindspore/train/serialization.py:319] The type of layer1.0.norm1.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.476.169 [mindspore/train/serialization.py:319] The type of layer1.0.norm1.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.479.179 [mindspore/train/serialization.py:319] The type of layer1.0.norm1.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.482.070 [mindspore/train/serialization.py:319] The type of layer1.0.norm1.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.488.503 [mindspore/train/serialization.py:319] The type of layer1.0.conv2.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.492.418 [mindspore/train/serialization.py:319] The type of layer1.0.norm2.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.495.372 [mindspore/train/serialization.py:319] The type of layer1.0.norm2.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.498.238 [mindspore/train/serialization.py:319] The type of layer1.0.norm2.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.501.022 [mindspore/train/serialization.py:319] The type of layer1.0.norm2.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.503.994 [mindspore/train/serialization.py:319] The type of layer1.0.conv3.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.507.411 [mindspore/train/serialization.py:319] The type of layer1.0.norm3.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.510.363 [mindspore/train/serialization.py:319] The type of layer1.0.norm3.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.513.232 [mindspore/train/serialization.py:319] The type of layer1.0.norm3.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.515.966 [mindspore/train/serialization.py:319] The type of layer1.0.norm3.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.519.073 [mindspore/train/serialization.py:319] The type of layer1.0.down_sample.0.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.522.254 [mindspore/train/serialization.py:319] The type of layer1.0.down_sample.1.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.525.079 [mindspore/train/serialization.py:319] The type of layer1.0.down_sample.1.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.528.149 [mindspore/train/serialization.py:319] The type of layer1.0.down_sample.1.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.536.906 [mindspore/train/serialization.py:319] The type of layer1.0.down_sample.1.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.539.567 [mindspore/train/serialization.py:319] The type of layer1.1.conv1.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.542.593 [mindspore/train/serialization.py:319] The type of layer1.1.norm1.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.545.376 [mindspore/train/serialization.py:319] The type of layer1.1.norm1.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.548.179 [mindspore/train/serialization.py:319] The type of layer1.1.norm1.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.551.175 [mindspore/train/serialization.py:319] The type of layer1.1.norm1.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.554.224 [mindspore/train/serialization.py:319] The type of layer1.1.conv2.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.557.648 [mindspore/train/serialization.py:319] The type of layer1.1.norm2.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.560.671 [mindspore/train/serialization.py:319] The type of layer1.1.norm2.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.567.165 [mindspore/train/serialization.py:319] The type of layer1.1.norm2.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.569.714 [mindspore/train/serialization.py:319] The type of layer1.1.norm2.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.572.510 [mindspore/train/serialization.py:319] The type of layer1.1.conv3.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.575.988 [mindspore/train/serialization.py:319] The type of layer1.1.norm3.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.579.242 [mindspore/train/serialization.py:319] The type of layer1.1.norm3.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.584.070 [mindspore/train/serialization.py:319] The type of layer1.1.norm3.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.587.054 [mindspore/train/serialization.py:319] The type of layer1.1.norm3.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.589.926 [mindspore/train/serialization.py:319] The type of layer1.2.conv1.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.593.121 [mindspore/train/serialization.py:319] The type of layer1.2.norm1.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.596.507 [mindspore/train/serialization.py:319] The type of layer1.2.norm1.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.601.575 [mindspore/train/serialization.py:319] The type of layer1.2.norm1.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.604.679 [mindspore/train/serialization.py:319] The type of layer1.2.norm1.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.607.645 [mindspore/train/serialization.py:319] The type of layer1.2.conv2.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.611.289 [mindspore/train/serialization.py:319] The type of layer1.2.norm2.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.614.390 [mindspore/train/serialization.py:319] The type of layer1.2.norm2.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.617.108 [mindspore/train/serialization.py:319] The type of layer1.2.norm2.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.620.466 [mindspore/train/serialization.py:319] The type of layer1.2.norm2.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.625.785 [mindspore/train/serialization.py:319] The type of layer1.2.conv3.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.628.915 [mindspore/train/serialization.py:319] The type of layer1.2.norm3.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.631.874 [mindspore/train/serialization.py:319] The type of layer1.2.norm3.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.635.128 [mindspore/train/serialization.py:319] The type of layer1.2.norm3.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.638.077 [mindspore/train/serialization.py:319] The type of layer1.2.norm3.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.641.021 [mindspore/train/serialization.py:319] The type of layer2.0.conv1.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.644.881 [mindspore/train/serialization.py:319] The type of layer2.0.norm1.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.647.892 [mindspore/train/serialization.py:319] The type of layer2.0.norm1.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.651.288 [mindspore/train/serialization.py:319] The type of layer2.0.norm1.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.654.204 [mindspore/train/serialization.py:319] The type of layer2.0.norm1.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.662.133 [mindspore/train/serialization.py:319] The type of layer2.0.conv2.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.667.373 [mindspore/train/serialization.py:319] The type of layer2.0.norm2.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.670.302 [mindspore/train/serialization.py:319] The type of layer2.0.norm2.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.674.634 [mindspore/train/serialization.py:319] The type of layer2.0.norm2.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.677.062 [mindspore/train/serialization.py:319] The type of layer2.0.norm2.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.680.452 [mindspore/train/serialization.py:319] The type of layer2.0.conv3.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.684.463 [mindspore/train/serialization.py:319] The type of layer2.0.norm3.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.687.537 [mindspore/train/serialization.py:319] The type of layer2.0.norm3.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.690.298 [mindspore/train/serialization.py:319] The type of layer2.0.norm3.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.692.731 [mindspore/train/serialization.py:319] The type of layer2.0.norm3.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.696.095 [mindspore/train/serialization.py:319] The type of layer2.0.down_sample.0.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.702.045 [mindspore/train/serialization.py:319] The type of layer2.0.down_sample.1.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.709.327 [mindspore/train/serialization.py:319] The type of layer2.0.down_sample.1.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.711.558 [mindspore/train/serialization.py:319] The type of layer2.0.down_sample.1.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.714.534 [mindspore/train/serialization.py:319] The type of layer2.0.down_sample.1.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.717.413 [mindspore/train/serialization.py:319] The type of layer2.1.conv1.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.721.640 [mindspore/train/serialization.py:319] The type of layer2.1.norm1.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.724.554 [mindspore/train/serialization.py:319] The type of layer2.1.norm1.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.730.422 [mindspore/train/serialization.py:319] The type of layer2.1.norm1.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.732.828 [mindspore/train/serialization.py:319] The type of layer2.1.norm1.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.735.630 [mindspore/train/serialization.py:319] The type of layer2.1.conv2.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.741.626 [mindspore/train/serialization.py:319] The type of layer2.1.norm2.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.746.670 [mindspore/train/serialization.py:319] The type of layer2.1.norm2.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.750.136 [mindspore/train/serialization.py:319] The type of layer2.1.norm2.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.753.490 [mindspore/train/serialization.py:319] The type of layer2.1.norm2.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.756.041 [mindspore/train/serialization.py:319] The type of layer2.1.conv3.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.760.111 [mindspore/train/serialization.py:319] The type of layer2.1.norm3.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.763.174 [mindspore/train/serialization.py:319] The type of layer2.1.norm3.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.765.512 [mindspore/train/serialization.py:319] The type of layer2.1.norm3.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.768.468 [mindspore/train/serialization.py:319] The type of layer2.1.norm3.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.771.473 [mindspore/train/serialization.py:319] The type of layer2.2.conv1.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.775.416 [mindspore/train/serialization.py:319] The type of layer2.2.norm1.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.778.255 [mindspore/train/serialization.py:319] The type of layer2.2.norm1.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.780.879 [mindspore/train/serialization.py:319] The type of layer2.2.norm1.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.783.914 [mindspore/train/serialization.py:319] The type of layer2.2.norm1.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.787.025 [mindspore/train/serialization.py:319] The type of layer2.2.conv2.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.792.288 [mindspore/train/serialization.py:319] The type of layer2.2.norm2.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.795.239 [mindspore/train/serialization.py:319] The type of layer2.2.norm2.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.804.892 [mindspore/train/serialization.py:319] The type of layer2.2.norm2.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.807.524 [mindspore/train/serialization.py:319] The type of layer2.2.norm2.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.810.070 [mindspore/train/serialization.py:319] The type of layer2.2.conv3.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.813.725 [mindspore/train/serialization.py:319] The type of layer2.2.norm3.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.816.840 [mindspore/train/serialization.py:319] The type of layer2.2.norm3.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.822.645 [mindspore/train/serialization.py:319] The type of layer2.2.norm3.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.825.112 [mindspore/train/serialization.py:319] The type of layer2.2.norm3.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.827.855 [mindspore/train/serialization.py:319] The type of layer2.3.conv1.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.832.564 [mindspore/train/serialization.py:319] The type of layer2.3.norm1.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.837.920 [mindspore/train/serialization.py:319] The type of layer2.3.norm1.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.840.501 [mindspore/train/serialization.py:319] The type of layer2.3.norm1.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.842.999 [mindspore/train/serialization.py:319] The type of layer2.3.norm1.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.845.917 [mindspore/train/serialization.py:319] The type of layer2.3.conv2.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.851.504 [mindspore/train/serialization.py:319] The type of layer2.3.norm2.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.854.654 [mindspore/train/serialization.py:319] The type of layer2.3.norm2.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.860.717 [mindspore/train/serialization.py:319] The type of layer2.3.norm2.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.863.083 [mindspore/train/serialization.py:319] The type of layer2.3.norm2.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.866.149 [mindspore/train/serialization.py:319] The type of layer2.3.conv3.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.871.282 [mindspore/train/serialization.py:319] The type of layer2.3.norm3.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.876.504 [mindspore/train/serialization.py:319] The type of layer2.3.norm3.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.879.066 [mindspore/train/serialization.py:319] The type of layer2.3.norm3.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.882.017 [mindspore/train/serialization.py:319] The type of layer2.3.norm3.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.884.922 [mindspore/train/serialization.py:319] The type of layer3.0.conv1.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.892.858 [mindspore/train/serialization.py:319] The type of layer3.0.norm1.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.896.495 [mindspore/train/serialization.py:319] The type of layer3.0.norm1.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.898.957 [mindspore/train/serialization.py:319] The type of layer3.0.norm1.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.901.424 [mindspore/train/serialization.py:319] The type of layer3.0.norm1.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.904.365 [mindspore/train/serialization.py:319] The type of layer3.0.conv2.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.920.258 [mindspore/train/serialization.py:319] The type of layer3.0.norm2.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.922.997 [mindspore/train/serialization.py:319] The type of layer3.0.norm2.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.925.640 [mindspore/train/serialization.py:319] The type of layer3.0.norm2.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.928.381 [mindspore/train/serialization.py:319] The type of layer3.0.norm2.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.931.323 [mindspore/train/serialization.py:319] The type of layer3.0.conv3.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.939.165 [mindspore/train/serialization.py:319] The type of layer3.0.norm3.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.942.334 [mindspore/train/serialization.py:319] The type of layer3.0.norm3.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.945.225 [mindspore/train/serialization.py:319] The type of layer3.0.norm3.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.951.792 [mindspore/train/serialization.py:319] The type of layer3.0.norm3.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.957.915 [mindspore/train/serialization.py:319] The type of layer3.0.down_sample.0.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.972.164 [mindspore/train/serialization.py:319] The type of layer3.0.down_sample.1.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.974.946 [mindspore/train/serialization.py:319] The type of layer3.0.down_sample.1.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.977.926 [mindspore/train/serialization.py:319] The type of layer3.0.down_sample.1.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.982.306 [mindspore/train/serialization.py:319] The type of layer3.0.down_sample.1.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.985.823 [mindspore/train/serialization.py:319] The type of layer3.1.conv1.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.993.761 [mindspore/train/serialization.py:319] The type of layer3.1.norm1.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:40.997.213 [mindspore/train/serialization.py:319] The type of layer3.1.norm1.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.638. [mindspore/train/serialization.py:319] The type of layer3.1.norm1.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.309.5 [mindspore/train/serialization.py:319] The type of layer3.1.norm1.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.612.4 [mindspore/train/serialization.py:319] The type of layer3.1.conv2.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.202.43 [mindspore/train/serialization.py:319] The type of layer3.1.norm2.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.235.23 [mindspore/train/serialization.py:319] The type of layer3.1.norm2.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.263.17 [mindspore/train/serialization.py:319] The type of layer3.1.norm2.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.295.01 [mindspore/train/serialization.py:319] The type of layer3.1.norm2.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.326.54 [mindspore/train/serialization.py:319] The type of layer3.1.conv3.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.410.55 [mindspore/train/serialization.py:319] The type of layer3.1.norm3.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.441.19 [mindspore/train/serialization.py:319] The type of layer3.1.norm3.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.470.28 [mindspore/train/serialization.py:319] The type of layer3.1.norm3.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.500.05 [mindspore/train/serialization.py:319] The type of layer3.1.norm3.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.529.97 [mindspore/train/serialization.py:319] The type of layer3.2.conv1.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.680.88 [mindspore/train/serialization.py:319] The type of layer3.2.norm1.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.711.40 [mindspore/train/serialization.py:319] The type of layer3.2.norm1.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.745.18 [mindspore/train/serialization.py:319] The type of layer3.2.norm1.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.769.95 [mindspore/train/serialization.py:319] The type of layer3.2.norm1.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.800.65 [mindspore/train/serialization.py:319] The type of layer3.2.conv2.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.947.86 [mindspore/train/serialization.py:319] The type of layer3.2.norm2.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.980.07 [mindspore/train/serialization.py:319] The type of layer3.2.norm2.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.100.942 [mindspore/train/serialization.py:319] The type of layer3.2.norm2.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.103.869 [mindspore/train/serialization.py:319] The type of layer3.2.norm2.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.106.622 [mindspore/train/serialization.py:319] The type of layer3.2.conv3.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.114.943 [mindspore/train/serialization.py:319] The type of layer3.2.norm3.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.117.958 [mindspore/train/serialization.py:319] The type of layer3.2.norm3.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.120.661 [mindspore/train/serialization.py:319] The type of layer3.2.norm3.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.123.415 [mindspore/train/serialization.py:319] The type of layer3.2.norm3.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.126.369 [mindspore/train/serialization.py:319] The type of layer3.3.conv1.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.134.696 [mindspore/train/serialization.py:319] The type of layer3.3.norm1.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.137.794 [mindspore/train/serialization.py:319] The type of layer3.3.norm1.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.140.596 [mindspore/train/serialization.py:319] The type of layer3.3.norm1.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.143.476 [mindspore/train/serialization.py:319] The type of layer3.3.norm1.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.146.410 [mindspore/train/serialization.py:319] The type of layer3.3.conv2.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.160.442 [mindspore/train/serialization.py:319] The type of layer3.3.norm2.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.163.628 [mindspore/train/serialization.py:319] The type of layer3.3.norm2.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.169.389 [mindspore/train/serialization.py:319] The type of layer3.3.norm2.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.172.241 [mindspore/train/serialization.py:319] The type of layer3.3.norm2.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.175.315 [mindspore/train/serialization.py:319] The type of layer3.3.conv3.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.191.305 [mindspore/train/serialization.py:319] The type of layer3.3.norm3.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.194.031 [mindspore/train/serialization.py:319] The type of layer3.3.norm3.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.196.665 [mindspore/train/serialization.py:319] The type of layer3.3.norm3.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.199.276 [mindspore/train/serialization.py:319] The type of layer3.3.norm3.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.202.847 [mindspore/train/serialization.py:319] The type of layer3.4.conv1.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.214.092 [mindspore/train/serialization.py:319] The type of layer3.4.norm1.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.216.717 [mindspore/train/serialization.py:319] The type of layer3.4.norm1.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.219.703 [mindspore/train/serialization.py:319] The type of layer3.4.norm1.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.222.690 [mindspore/train/serialization.py:319] The type of layer3.4.norm1.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.227.547 [mindspore/train/serialization.py:319] The type of layer3.4.conv2.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.242.936 [mindspore/train/serialization.py:319] The type of layer3.4.norm2.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.245.377 [mindspore/train/serialization.py:319] The type of layer3.4.norm2.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.248.031 [mindspore/train/serialization.py:319] The type of layer3.4.norm2.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.250.718 [mindspore/train/serialization.py:319] The type of layer3.4.norm2.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.253.705 [mindspore/train/serialization.py:319] The type of layer3.4.conv3.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.262.197 [mindspore/train/serialization.py:319] The type of layer3.4.norm3.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.265.305 [mindspore/train/serialization.py:319] The type of layer3.4.norm3.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.269.313 [mindspore/train/serialization.py:319] The type of layer3.4.norm3.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.272.280 [mindspore/train/serialization.py:319] The type of layer3.4.norm3.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.275.154 [mindspore/train/serialization.py:319] The type of layer3.5.conv1.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.283.577 [mindspore/train/serialization.py:319] The type of layer3.5.norm1.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.286.657 [mindspore/train/serialization.py:319] The type of layer3.5.norm1.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.293.162 [mindspore/train/serialization.py:319] The type of layer3.5.norm1.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.296.385 [mindspore/train/serialization.py:319] The type of layer3.5.norm1.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.299.258 [mindspore/train/serialization.py:319] The type of layer3.5.conv2.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.313.037 [mindspore/train/serialization.py:319] The type of layer3.5.norm2.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.316.298 [mindspore/train/serialization.py:319] The type of layer3.5.norm2.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.319.199 [mindspore/train/serialization.py:319] The type of layer3.5.norm2.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.324.734 [mindspore/train/serialization.py:319] The type of layer3.5.norm2.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.328.130 [mindspore/train/serialization.py:319] The type of layer3.5.conv3.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.336.352 [mindspore/train/serialization.py:319] The type of layer3.5.norm3.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.339.822 [mindspore/train/serialization.py:319] The type of layer3.5.norm3.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.342.210 [mindspore/train/serialization.py:319] The type of layer3.5.norm3.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.344.684 [mindspore/train/serialization.py:319] The type of layer3.5.norm3.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.347.574 [mindspore/train/serialization.py:319] The type of layer4.0.conv1.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.363.120 [mindspore/train/serialization.py:319] The type of layer4.0.norm1.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.366.745 [mindspore/train/serialization.py:319] The type of layer4.0.norm1.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.369.121 [mindspore/train/serialization.py:319] The type of layer4.0.norm1.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.371.774 [mindspore/train/serialization.py:319] The type of layer4.0.norm1.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.374.604 [mindspore/train/serialization.py:319] The type of layer4.0.conv2.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.422.988 [mindspore/train/serialization.py:319] The type of layer4.0.norm2.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.426.757 [mindspore/train/serialization.py:319] The type of layer4.0.norm2.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.430.795 [mindspore/train/serialization.py:319] The type of layer4.0.norm2.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.433.702 [mindspore/train/serialization.py:319] The type of layer4.0.norm2.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.439.708 [mindspore/train/serialization.py:319] The type of layer4.0.conv3.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.462.610 [mindspore/train/serialization.py:319] The type of layer4.0.norm3.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.465.929 [mindspore/train/serialization.py:319] The type of layer4.0.norm3.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.468.823 [mindspore/train/serialization.py:319] The type of layer4.0.norm3.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.473.787 [mindspore/train/serialization.py:319] The type of layer4.0.norm3.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.477.078 [mindspore/train/serialization.py:319] The type of layer4.0.down_sample.0.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.522.531 [mindspore/train/serialization.py:319] The type of layer4.0.down_sample.1.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.525.505 [mindspore/train/serialization.py:319] The type of layer4.0.down_sample.1.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.529.747 [mindspore/train/serialization.py:319] The type of layer4.0.down_sample.1.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.532.027 [mindspore/train/serialization.py:319] The type of layer4.0.down_sample.1.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.535.028 [mindspore/train/serialization.py:319] The type of layer4.1.conv1.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.559.593 [mindspore/train/serialization.py:319] The type of layer4.1.norm1.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.562.580 [mindspore/train/serialization.py:319] The type of layer4.1.norm1.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.566.927 [mindspore/train/serialization.py:319] The type of layer4.1.norm1.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.569.421 [mindspore/train/serialization.py:319] The type of layer4.1.norm1.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.572.600 [mindspore/train/serialization.py:319] The type of layer4.1.conv2.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.622.168 [mindspore/train/serialization.py:319] The type of layer4.1.norm2.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.625.385 [mindspore/train/serialization.py:319] The type of layer4.1.norm2.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.628.083 [mindspore/train/serialization.py:319] The type of layer4.1.norm2.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.631.037 [mindspore/train/serialization.py:319] The type of layer4.1.norm2.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.634.056 [mindspore/train/serialization.py:319] The type of layer4.1.conv3.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.657.151 [mindspore/train/serialization.py:319] The type of layer4.1.norm3.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.660.321 [mindspore/train/serialization.py:319] The type of layer4.1.norm3.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.667.995 [mindspore/train/serialization.py:319] The type of layer4.1.norm3.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.670.732 [mindspore/train/serialization.py:319] The type of layer4.1.norm3.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.673.311 [mindspore/train/serialization.py:319] The type of layer4.2.conv1.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.696.004 [mindspore/train/serialization.py:319] The type of layer4.2.norm1.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.699.172 [mindspore/train/serialization.py:319] The type of layer4.2.norm1.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.701.797 [mindspore/train/serialization.py:319] The type of layer4.2.norm1.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.704.768 [mindspore/train/serialization.py:319] The type of layer4.2.norm1.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.707.638 [mindspore/train/serialization.py:319] The type of layer4.2.conv2.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.761.133 [mindspore/train/serialization.py:319] The type of layer4.2.norm2.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.764.056 [mindspore/train/serialization.py:319] The type of layer4.2.norm2.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.766.907 [mindspore/train/serialization.py:319] The type of layer4.2.norm2.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.769.477 [mindspore/train/serialization.py:319] The type of layer4.2.norm2.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.771.995 [mindspore/train/serialization.py:319] The type of layer4.2.conv3.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.794.795 [mindspore/train/serialization.py:319] The type of layer4.2.norm3.moving_mean:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.800.566 [mindspore/train/serialization.py:319] The type of layer4.2.norm3.moving_variance:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.803.308 [mindspore/train/serialization.py:319] The type of layer4.2.norm3.gamma:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.806.228 [mindspore/train/serialization.py:319] The type of layer4.2.norm3.beta:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.809.101 [mindspore/train/serialization.py:319] The type of fc.weight:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n",
      "[WARNING] ME(13613:255086276112416,MainProcess):2025-07-12-13:28:41.812.445 [mindspore/train/serialization.py:319] The type of fc.bias:Float32 in 'parameter_dict' is different from the type of it in 'net':Float16, then the type convert from Float32 to Float16 in the network. May consume additional memory and time\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "import mindspore as ms\n",
    "from mindspore import load_checkpoint, load_param_into_net\n",
    "\n",
    "# 下载权重文件ckpt\n",
    "resnet50_url = \"https://modelers.cn/coderepo/web/v1/file/MindSpore-Lab/cluoud_obs/main/media/examples/mindspore-courses/orange-pi-online-infer/02-ResNet50/resnet50-best.ckpt\"\n",
    "path = \"./resnet50-best.ckpt\"\n",
    "best_ckpt_path = download(resnet50_url, path, replace=True)\n",
    "\n",
    "# 模型实例化\n",
    "num_class = 10\n",
    "model = ResNet(ResidualBlock, [3, 4, 6, 3], num_classes, 2048)\n",
    "\n",
    "# 加载模型参数\n",
    "param_dict = ms.load_checkpoint(best_ckpt_path)\n",
    "param_not_load, _ = ms.load_param_into_net(model, param_dict)\n",
    "\n",
    "print(param_not_load)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2899828",
   "metadata": {},
   "source": [
    "> `param_not_load`是未被加载的参数列表，为空时代表所有参数均加载成功。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46e28f6f",
   "metadata": {},
   "source": [
    "## 可视化模型预测\n",
    "\n",
    "定义`visualize_model`函数，对CIFAR-10测试数据集进行预测，并将预测结果可视化。若预测字体颜色为蓝色表示为预测正确，预测字体颜色为红色则表示预测错误。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "6ba2fa94",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-23T16:14:25.787377Z",
     "start_time": "2024-07-23T16:14:23.737793Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[WARNING] DEVICE(13613,e7ffe6dff020,python):2025-07-12-13:28:42.978.005 [mindspore/ccsrc/plugin/res_manager/ascend/mem_manager/ascend_memory_adapter.cc:123] Initialize] Free memory size is less than half of total memory size.Device 0 Device MOC total size:7912181760 Device MOC free size:3752603648 may be other processes occupying this card, check as: ps -ef|grep python\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ".."
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcoAAAGbCAYAAABETtCOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAABdDklEQVR4nO29ebRlZ13m/5x5vvO9NU+pDJU5JCGBAEYGBVRo/IFIsxBoAg6M2mq3/prV4NIlulBE0NbG1QTBqQnBiMpsGEIgCSSYkUqqKjUPt+48nHnYvz/2r9atqufZu05CSN0yz2etWrfu9+797nfvs9/3e/Z5n/N8E0EQBDDGGGOMJHm2O2CMMcasZpwojTHGmBicKI0xxpgYnCiNMcaYGJwojTHGmBicKI0xxpgYnCiNMcaYGJwojTHGmBicKI0xxpgYnCj75OtfBxKJ8OcJ3vxmYOvWs9Ofp5sf/3HgssvOdi+M+Y/DapxTfvzHw3/mVJwozwK///vAbbf1v/3f/R3w4Q//qHpjjDnXeaJzinliOFH+EPzVXwGPPvrE93OiNMYonq45xTwx/sMnyl4PaDR+NG1nMkAu96Np+8nSaITnbIz50fBMm1PMOZQo3//+8PP8nTuB174WGBgARkeB97zn1Js2kQDe+U7gb/8WuPTS8Kb74hfDvx0+DLzlLcCaNWH80kuBj3+cj3XoEPCqVwGlEjAxAfzarwHNJm+n1hN6PeBP/xS4/HIgnwfGx4GXvQz43vdW+letAn/91+H/E4mwnRPs3AkcOLDy+4//OPCv/wrs37+y/Yljnljj+Id/AN77XmDDBqBYBBYXV67X6XziE2F8375T41/4AnDjjUClEl7bZz87fJKN48tfDo/3n/8z0OnEb2vMauOZOqec4GMfA7ZvBwoF4LrrgDvu0Nfp+HHgppvCc8zngSuvDI91OjMzwC/8Qngdh4aAN70JuP/+sD+f+IRu+1whfbY78ER57WvDG+kDHwDuugv4yEeAuTngk59c2eb224FPfzq8ucfGwu0nJ4HnPGflph8fD5PDTTeFieVXfzXct14HXvzi8MZ697uB9euBT30qbLMfbropvCle/nLgrW8NE8gdd4R9vfbasK23vjW8MX/xF8N9tm9f2f/ii8OEdWKB/3/8D2BhIRxof/InYaxcPvWYv/u7QDYL/MZvhIMvm31ClxSf+EQ42C+9FPjt3w5v8u9/P5wMXv96vc+//AvwmtcAP//z4cSQSj2xYxqzWnimzSkA8H/+D/BLvwTccEPYz8cfB175SmBkBNi0aWW7ej18s757d3iO27YBt9wSJuL5+fBNBRAm81e8ArjnHuBXfgXYsQP4p38Kk+V/CIJzhPe9LwiAIHjlK0+Nv/3tYfz++8PfgSBIJoPg4YdP3e6mm4Jg3bogmJ4+Nf661wXB4GAQ1Grh7x/+cNjGpz+9sk21GgTnnx/Gv/a1lfib3hQEW7as/H777eE2734397/XW/l/qRTuqwCC4MYbT4399E+fepwTfO1r4fbnnbfS/xOcuF6nc/PNYXzv3vD3+fkgqFSC4Prrg6Bej+7zjTcGwaWXhv+/9dYgyGSC4G1vC4JuV5+HMaudZ+qc0moFwcREEFx1VRA0myvxj32Mtz3R97/5m1P3f+5zg6BcDoLFxTB2663hdh/+8Mp23W4QvOhFYfzmm3XfzhXOmY9eT/COd5z6+7veFf78/OdXYjfeCFxyycrvQQDcemv4jicIgOnplX8vfWn4xHbffSvtrFsXPi2doFhceacWx623hu8u3/c+/pv6GFQRBKe+8+uHN70p/PjkyfCVrwBLS8Bv/Vb4scrJqD7//d+HT5G/9EvA//7fQPKcu4OMOZVn2pzyve+FH6f+8i+f+unTm98MDA6euu/nPw+sXRsur5wgkwmfjJeXgW98I4x98Yth/G1vW9kumeRre65yzn30esEFp/6+fXv4gpy85rZt26nbTE2FHxN87GPhP8Xx4+HP/fuB88/nm/Cii87ctz17wo9VRkbOvO1Tyenn+0TYsyf82c93JPfuBd7wBuDnfg746Eef/DGNWU080+aU/fvDn6efdyYDnHceb3vBBfyG+OKLT21r//7wzUCxeOp255//1PT5bHPOJcrTUe+qTn+6OqECfcMboj8zv+KKp7ZfTyfqaTLq3Wa3++SPs25d+O/znw/flV577ZNvy5jViucUczrnXKLctevUd3e7d4c3bZybxfh4qObsdoGXvCS+/S1bgIceCj+uOHnA9PPdpu3bgS99CZidjX8H2O9HJk92ewAYHg5/zs+H4pwTnHgHeIITi/4PPXTmd3/5fCjiedGLQtXdN74RCoCMOZd5ps0pW7aEP3ftCsfyCdrt8FOjK688ddsHHgivx8lPlTt3ntrWli3A174G1GqnPlXu3t1/v1Yz59wK05//+am/n/gI8OUvj94nlQJe/erw8/6HHuK/T02t/P+nfgo4cgT4zGdWYrVa9McrJ/PqV4eD4Xd+h/8WBCv/L5XCBKZQUu5SKVzzeCKcSIDf/OZK7ISE/GR+8ifDAf+BD/B3w07u8wkGB8OBOzEB/MRPrHx0a8y5yjNtTrn22jDR/+VfAq3WSvwTn+A2fuqngGPHgP/7f1dinU54jcrlcO0WCNdl2+3QMOEEvR5f23OVc+6Jcu/eUMb8spcB3/kO8Dd/E36F4eR3QYo/+IPwHc/114cLzpdcEr5Lu+8+4KtfDf8PhH/7sz8D3vhG4N57w48aP/Up/uxd8cIXht8j+shHwndrL3tZeLPccUf4t3e+M9zummvCY37oQ+H6w7ZtYb8ALeW+5prwRv2v/zX8fmO5HIoI4vjJnwQ2bw6l5b/5m+HA/vjHwwFy8qAZGAi/dvLWt4Ztv/714dPo/feHg1l9X2psLBQBPf/54bvpb30r/A6nMeciz7Q5JZMBfu/3QkHei14UivP27gVuvpnXKH/xF0PR3pvfHPZ969Yw4d95Z+gWVqmE273qVeHXU37918OnyB07gM99buUaPJlPxVYVZ1t22y8npNyPPBIEr3lN+JWG4eEgeOc7T/1aAxAE73iHbmNyMvzbpk3h1xvWrg2CF784lEWfzP79oWS8WAyCsbEgeM97guCLXzyzlDsIgqDTCYIPfjAIduwIgmw2CMbHg+DlLw+Ce+9d2WbnziD4sR8LgkIhbPNkWbf6esjychC8/vVBMDQU/v3EMU98PeSWW/T53ntv+LWPbDYINm8Ogg99iL8ecoLPfS4Ibrgh7NPAQBBcd10Q/P3fr/z95K+HnGD37lAef/HFQTA1pftgzGrlmTynBEEQ/K//FQTbtgVBLhcE114bBN/8Zrjd6dtOTgbBf/kvYb+z2SC4/HL9dY+pqXCeqlTCr8e8+c1BcOed4fH/4R/09TtXSASB+oBt9fH+94cfP0xNhU80xhjzw+A55UfPbbcBP/uz4adOz3ve2e7Nk+ecW6M0xhiz+qjXT/292w3XMgcGgKuvPjt9eqo459YojTHGrD7e9a4wWT73uaGV5mc/C3z722FlkydriLJacKI0xhjzQ/OiFwF//MfhV8gajfDrZh/96Irg6FzmnFmjNMYYY84GXqM0xhhjYnCiNMYYY2Loe43yh/98ttffcXr9HymR7LMIYn+HDo/f51uHp+v7s0/kevzw8FmpD+blp/URn+D3uhzv9vp7QdKpiNsz4P0zeRfEXK0876qNFMtneKANF0ty/0ohL6J8D3TE2E1A3xfNRpti1WWupNxockXyam1ZttlTxcvFhFIqc8HYDZv091PGh3MUy6XYsFmNlETErJ3oimvX5uvRafH+jbYeuwuLfO2WanxBlmotijUC/RoFCY5nMnyms0vc5uEFjgFAO8nXfn5GVLU+DT9RGmOMMTE4URpjjDExOFEaY4wxMThRGmOMMTGc24YDT0Ck0y+Jftt8mt5iJJIRsqE++yk1Nk9AiaRd/4Xo5wnsnxTBRIIvaDIV0dF+FVdmVZDPsSAFHRZb9KKqiqt7SAj5cmklCtH3UC7DfcrmWDRUW65RrBQhHGs1hUhGiPG2bmVx08ZNuthkr7dIsWSXxUTl0gDF8hkWrgBAt6XEPEIgJK5xJ2LeOT4zR7HBGrfZFEKixRoLiQCgJgRGqSSnrFSBz3O2PSvbRFcprs6MZxxjjDEmBidKY4wxJgYnSmOMMSYGJ0pjjDEmhlUn5mk0ePE8m1XOHEAqqfL80+WZ8wToV3gjHGt6UZ71P5SgJeIaJcSxxKYJIcZJRomORDz1w74/C1bha2wiyab59W53+TVsC8clQN/qiRQLTRJqPhAiMQBIif0LQjyWz7NIpl1vyDbnZpYolktmKLZ+LbvwbFw/IdtsNJVwiGtWjY/y/qWsdjoKhCJHuWWlhAtOOi2EWQBGjh2n2OISi45SKZ7LZ5d4zgeA6dl5ii0vLlCsk2BXoEpFp7ZcoPt/JvxEaYwxxsTgRGmMMcbE4ERpjDHGxOBEaYwxxsTgRGmMMcbEcFZVr6rWoqxVGKH8lLUahSBSiSSjVJqyTRUSdRaVGjSiS/I4ysKrLay+AKDT6++lkwrViH4CfHxloZcQZxTVpLSmE20mU7xdlOBXiXNXpdrZAACadVYlpoTCNJtlhSgAdMWNkBb3VSYt9o9QvWayrCbtKdV5h23UMgltDVevcptpYSNXLrPyc2x8SLbZqHOs2+M+5bKshC0PsGIXAIrCqk8NqXSeFaKFQlG2OTTCFnyzs2xrVxI1R5ciLOz2HzhIscd2P0axyQW2+cuktIJa3Xf94CdKY4wxJgYnSmOMMSYGJ0pjjDEmBidKY4wxJoanTcwT4U71wyHWZXtiWVoJhKp1bZtUKZQplhZCE1mTUdRaC7cU24o+LQl7JiUwAIBEikUCqQyLGTotXiiv1thaCtCCGlVLMCmswmoR13O5yseqVPgaj42wrVeUOCqZYNFEErpGoDn7FAssNEloRZak1WORWVYMyYwQqaSFfR4AFHKirqFoNC2EZ52GrmnYa3M8meAxKdzzgIhanLPzVYrNzfGYyou+b9+qx0RlPY+/nng9loQIq9XV1zMQY7JUYuFOStS4TEKLeZToMCfmuGyG28wLIRIA1FsRNU/PgJ8ojTHGmBicKI0xxpgYnCiNMcaYGJwojTHGmBieRmee/pxoogQcskWxab3JteL+/tZbKPbgww/JNq+99tkUu+ryKyi2ee1ailUKFdmmqsnYanE/d+/eTbF8noUQADA8Pkqx8TLXpJtaYneMY8ePyTaz2f5qteVyLCSamZmR27ZbQhAwxsIdRT6iP6kk37ZDI0N9tWmefkrCzSWVUeNcC9eKRR4DA5VBihXE/ZIVoh1Au+Nk8ywKyQq3n+o8150EgHlRP7Hd4nPqiLG/uMRCPgCYm2Yxz/0PPU6xdJIFMYWIuSMtLkm7y/s/svswxTotLcK66PxtFBsQLjyJgOeD41Ozss0FIW5MirGfFgKhXISIKyOckvrBT5TGGGNMDE6UxhhjTAxOlMYYY0wMTpTGGGNMDD8CMY9e7FXuNMvCIWbvnr0Uu+CiC2WbebH4/pAQ6Xz5S1+i2Njacdnm3d+7h2KFAosE6otc2mXDOItpAC08WFri/ffu30+xnHDGAYBrJrisTS/gBfm5ORbZJBJaNLHncRYTLQqBQnmQy/csiJI6AFAssZDj6JGjFMsJJ41KmcUAAKTm4ydf/jK9rTnrFAs8TstlvoeKJRbYAEAux4KaTIaFKilheZPJ6GeBohAYFcR80hVuO922nuOqVa6JVW/ymJxd5O2yJRa5AMDkPJfZOzLL2xayPCj2H9Fj8vgci2eyWU4F9/47l7Sam9IOXAOl9RRLr+PXKJ/l6zEfIWSamuf8UC6yq1CpxPdSYmZatqmcffrBT5TGGGNMDE6UxhhjTAxOlMYYY0wMTpTGGGNMDE6UxhhjTAxPQPXaX0HJqLqTCbG/qmuYEP5KEWUeUauxlVRBqNx+/U1vpFgmpU89PcAKqjUbt1BsdnqSYvseZ8UuAHSEW1dJWCkNDLEFXidCRdwT73Fm5uYp9uA991IsXdI2Tjsf20Wx5jJbaK1ds4Zi0xEWdhBWUqo+6ILou7g9AADFEl8nq15XL2Vxvw1WWOVcLLGiEQByqnZkmhWyXaGsT8laskAhLyzshK1eS0w+6jgA0BVDNSVs9WYWWDlabfJ8AgD3PcRK9GpT2IGK+eCe+1m1CgD1GqtM10wM83FqbDFabejJ+H6hkF2/5vkUSwp17tSstrCbXeT5vTzA98jwCH8DYGlZ17hcXmT7wH7wE6UxxhgTgxOlMcYYE4MTpTHGGBODE6UxxhgTwxMQ8/ACdtDTQpN+908Ly6lUQsREPUcAmJ9nG7gxUevw8X1cVy0T4Y42McZ1HtPi/USxzPZMhw/oheJ6jxeWG2rhP8+ih5KohwcA0wePUKwpjtMS9SBrXd3PqRkWFOQSfIvMC+HO1HEtRkCG91d1SGt1tqvKRKh5BqKs7cyqZGCAxVdq/OSL+l7PCUFMOstjpdXhQZWMEiGmeKyoLZttFrPV6xE2boMsiJkS1o6Lx6coFiUQatXZ7q5SZEvMjhj7s3O8LwD0ejwmH32cLd/WCJvM4aEh2eYjjz5KsYlxFkxddvlGis1Ma6u9oCvEVR22FFS2qcr2EABqSYt5jDHGmKccJ0pjjDEmBidKY4wxJgYnSmOMMSaGH0rMkxAimyiBTyD27wW8bbfD9ddadV5QDzvAbS5VebH26DwvFg8EvCAOAHOPscNEu8sCo5l5rqmYCvQCcrHE4hPRJLotPveZXQdlm8caLNIpblpLsYktmyiWTOj3R5VBvib3fucuii2IWpozs7r+W7PDwp1iiYUc6tw7KS1wqNUi7gezKikN8f2v6kGqcQIAhQKLQjodlt4kUqJ2pBCO/f9/iYifyswMC2/mF7WYBwkWGDWb3KekqIk4NMBCIADotFQdXx77PaVxSej6noksH79Z5TFdb/I1Kg/q+rh5UUv0uJgT9u4VTkdCtAMAiYToZ4NFS11hBxcE+vVNZp6IAPWk/Z7UXsYYY8wzBCdKY4wxJgYnSmOMMSYGJ0pjjDEmhr7FPN22cFOpCTcVsVANAEnhMKMMdybWsBvEzJwWivzrF/+NYlNzLNzp1tihotHSDg2NNotKanU+9zzrUTBQ5hJdADAsHDsuuOgCiuVE6a39D+2UbU4dOECxK17xYooVUxMUywq3HQAYFK4bCVGmaHmRy/Q02xFlbWosfEgmeEG9La57hJYHR/bt038wq5JkmgUgmSwPoGxODCoAqRTPHcLACxmhM2ksc6kmIELkI2KLCyxyaXcini+UQC/gm3h4mN3DRsbGZZOHjhynWK4grl1SOGAJ0Q8ABELkkxcal9k5duCKmjt2XMzz2baNfJ7NGrfZbmuBTTovcoZwc4MQhRaLWsjUbOprcib8RGmMMcbE4ERpjDHGxOBEaYwxxsTgRGmMMcbE4ERpjDHGxNC36nX/vt0U27WbY5UBrfy86OIdFMtlWMHUFerHY8e59iIAHDzC8Xlhd5eosyIzKyyXAKAtaiCmctzPkWG229q5k+3vAGBuZp5im7dvpZhSveYjajKOCNltu8nq3ukpVpmNDnLNTQBAgn2wGqKe5dz8PMVqNa0ibjZY9drO8XkmRU05Va8UANJpv787l8iI4q/pvIhlI+qMCnl8Ls1Tl7qHasva7jAprDa7sq4h9ynf1fdfQ9nICevOckXU5yyWZZsdce5r1q6jWLPFc1wqz3MpACDJ42+gxfPh5CSP3RmhAgaAXo8Vw6Oitu/MFPdpeVnbdA7nOZcEXTFPpHmeKOS11d5chJL+THjGMcYYY2JwojTGGGNicKI0xhhjYnCiNMYYY2LoW8zz6A9+QLHJyWMU665ZoxsIxEo3lxFDs8mikJkFtqUDgLWi/uKAsFKb3HeYdxaWemGfeLE46HFHq0IkMDer+9kRC929rqihJmJLdRboAEBKWAV2Rd974rqr+m0AUBM1IetCIDS3ME+xpWW2MwSATofFQItiQb1SZNFEJkK0U4u4JmZ1kkqz8CwBFo8EEfVcez2+YZpNNSbZWnF5Ud8rm9byPFUssABk8hiL4ZYibNBSwomtI+zVlpZ47kgq/z0AHdFmQ9RabIlxls5o5UpS7J/Ls8BnZESJcbgOLwAcPMqCnGuTl/BxCjzOm62o2qA8/tNi3uuIGsZIalu88QirwDPhJ0pjjDEmBidKY4wxJgYnSmOMMSYGJ0pjjDEmhr7FPEFPiGSO88JuIqmFIkeO7KfYhnFeUG82eWF2XtSTBICBkUFuU9R+XJxikc1shMNEIJw0EuKUjhxhgVCzofsZJLjNpHCYEGUasSDENAAQiPiwchtp8PVs5rWLTrbI/azXWSSwtMg1/upChAUALeHs0xWCqxR4QX95US/y98R5mtXLwjQLYupJFrTkCkW9vxBvLS3xmK4UeDobHOQ5AgAGRrnubSBEd1Uh3GmLsRvCDjGNBo+L48d57ohym2oLgV21ym2ev/08ikU9BdWWeO6bmWEhVDLJ55PJasHVUpVfz7oa+6pXmYg0JJy5ikV265kV9YrbTV0ftxlVS/QM+InSGGOMicGJ0hhjjInBidIYY4yJwYnSGGOMiaFvMU+1IQQcdRGrRSzIz/CC6+YJdtbJihJMTSH+AICZOV7QXxYil3qV+1ld4sVrAKg1eUF/IMtlcZqirNTYqC5fdegYOxhJzwzh4nH1c6+TbUKInroDfO1bXXbmSaW1Y4dyC+p2+No3xSJ9T7h9ABHnKcoZVZe5pI86NgB0A7+/O5fY9/heijUXefyUBobk/jM1cW/0+B68Ysd2io2P6zGpJIf7Dx6g2L7DLLwZKnGZKwBICjWeulMDIdApFfQ9rVx0GsIVbOvmbRTL57TbT12Uvnvs0V0Um555lGKtCNHegJh7SmWeN4/Mc2nEjJjzASCTZ+FQIsHbtpuivFpE2b9GQ4tNz4RnHGOMMSYGJ0pjjDEmBidKY4wxJgYnSmOMMSYGJ0pjjDEmhv4t7FqsFlo7PkGxTFormB54iBVU7R5bFM0vcF3D5jyrvABgcZpVr4UqKyXzea59Ny5qrQFAOsWXJC/OaXdtimILou+AtsBT71GCBMcGN2iFnSrv2QSfezHFbXa7Wova6bFSrCv0gc2GUKMGoiYcIH35OkKQ1hQ15dJpbRXW0mJYs0pZbLByM5UWdm9dfQ/l8rxtucJ1BTdu2UqxNWv0+Gm1WB1/7NgkxRZmWR1fCFjNCQDZLCs/h8tcfzGb4fO54sKLZJtzS6xQ/e4DXBv4u3ffQbEBYecJAJk0z4dzYi5VVnetJvcHACbGNlCsVOQ6pK0WD/60uBcAICtqBrdF3c2eUPZnxTwOAIMT2tLwTPiJ0hhjjInBidIYY4yJwYnSGGOMicGJ0hhjjImhbzHPt75/LweF1qIXkXpV/cVjkyyIed3rXk+xFzzvBbLNplC0JIQgRgl0cgVe0AaApLCR++Y3vkGxcllY9QXaHimTZTHQ3MIsxQ4ePiiajLBcUnXVhI6q2xMWdmpDQCqEJsZYNFHMs0ChVo+o/1ZnIVYxz2KITIYX7nvCpgwAEFjNcy6x+wDXrR2qsNBj/ZoxuX+xyGO1IsbfwACLVxKipiEAdDo8zgtKjDPA4o+aqMcaNsBjNRB2jzkxftZNsDASAF7+Ep772uA2d/7gEYo1atpWEmBru0Bcj1Sa91+/Tr9GF59/PsVGhnicZ0XNzlKO7wUAyIk5ISFq0eZyvN1QaUi2iSdpf+knSmOMMSYGJ0pjjDEmBidKY4wxJgYnSmOMMSaGvsU8XVHHKyWrDWo3lUaXHRm2X30txdauXUOxXF4v9haSfPxAiHHqotZhc0m7/ew/uJ9ii2Lx/pJLdnA/I+qqpcWi9OGDXOeuKxwmuh0t5umlxEJ9krfNZbhP+WREP5MsmkhMsLPJ6DjXEU3Oa7ef2vI8xdauY+FCIccCh65wCgKATlu/dmZ10mnxvTovxl8gXJwAYO0Ei3Q2bt5EsZqo0XpskuvgAkCrJo4vxtroIItXJpePyzbrwrWmKeo3JpJliinHGQDYtHk9xV5y4/MpVsry2N23l2s/AkC7yWN1eJiv8foN7F62eRPPzwBwwfn8eqDN81nQ5tdocIDHPgDkMpyeEsIprJDl7YpC4AMAM8dZRNkPfqI0xhhjYnCiNMYYY2JwojTGGGNicKI0xhhjYuhbzIN5XpQuFNjJoicENgAwvcDlavbue5xiH//4zRQ7epidPQAgmeTup9Oc+7ds3UKxckkvIOfL7CaRFuVeul1eVJ4X5wjodyMp0c9KiRf5EUS5a7DwIRAL3Wlx9NYylxgCgEDUr6oKIdOx4+yolM1pB5S163nxf2xshGKJFAuMkkn9GnVb7CxiVi/DwnllscPCl+kZPX66wtVr3Qa+h4drHEtFiAuX51nUMT8zL/YX43RoQLdZFWX2xLCojLDbT0E4FQFAoy7OSUwoV152McXO27pNttlt8jwxMcHjdP16FjIVIsY5RIm//bv3UawlzicZUfavWefrKaZNFIWIsiRKKwLAsc6Tc/XyE6UxxhgTgxOlMcYYE4MTpTHGGBODE6UxxhgTgxOlMcYYE0PfqteRTRsoppSf2YjUWz26l2JLQlF55PAkxb7ypa/INhOitlhC2GC95tU/S7FNWzbLNidErbiEEHolhFArk9aKsF5XKFeF1R4gttOCMOgye3w9uk22kdq/d7dss9sW9fSEjdTomFDD5fW5X3PFcyhWb7Dy7NAkv+5bt54n20x02AbLrF4GhEyzFbCSfDmi9OrSMr/ee/YcoFgixYOlK1SWAABhd4cm28gpEf/wKNu9AUBugL8FUKqxmnXdJraly5S0SlOVuM0JhXhlDSvmi9u0arzZ4GuSTnObo8PiGwAZrSKeOjJHsclJttCrLi5SbFlY3QFALs/q9oEKn1O5xCrikWGOAcDhglYXnwk/URpjjDExOFEaY4wxMThRGmOMMTE4URpjjDEx9C3mue/hByj2+C4Whey44AK5/4UXcXx8nG2Tup1j3OZFXPsRADIZXuzNCkHN4NAQxZaXWUgEANkFXpQeHmHLtY6oq9ZoauFAArxY3WmJ2pNi5T6t/Kqg61QeOcLX7vHdLKI6bz2LCQAgU+Hr2RJ9v0i8lutG9eL5yACLNhYafO3m6xwbGh6XbfaE1Z5ZveQzPCaHhGiu19A1GatC7DEnRCFHDxyiWKqn75WSqBGrqAzwfT04osU8+S7fw7k838Nj47x/XQiJACCXZvFJMc8im2KRx26hqAVCqRTPHT1h9dcR4sJuU1tqNlqi/z0+TrvF1oWNKscAIJfnebeQ59etXOJrlC+xsAoAskIg1A9+ojTGGGNicKI0xhhjYnCiNMYYY2JwojTGGGNi6FvM88jd36NYdYnrhR0S7i4AcOWzLqXYpk2bKHbsKAtSHniAhUQA0BGGDsqZ55rrrqbYug3rZJvZHNeau/Nb36FYu8vCnYsv1kKmZERNvNORDj5ZLToQJiT4wQ92UeyBB/naXXzBdt2mrLvJB6oI4UBeuQoBaCyxwGGhytdudo7FGY8+xvVKAaDR4NqoZvWSz7DrS0KMiV6E60tCOV6JOq0Dou7lsHBtAYCUGEBziywqSRfZ8SZX1I43gXCcGhxkUUlSnE9D7AsAEKIjUZ5TxhrKfQhAJsfjNykswNRM3lFzFIBkkvtZzPO5jwvRX66s09C6jTxHDw6xEKpS5jk7mdROYZmCFjidCT9RGmOMMTE4URpjjDExOFEaY4wxMThRGmOMMTH0LeZpp3m1eM15Gyl22eVXyv1n59jx5u67WCSzew8LODaIsjQAkErx4n2zxUKPQ4cOUyyT1Yu9Cwvs7vHZf/wsxcpFFihEiXn0sjijSvokVD0vaMee6jKLq7J5XrxeihDDJBLsrlFts/AmEK5As8eOyzbbQuQz0+T9U6J0ULWq+5nN6dfOrE5ySqgiXFvGi7oE0kiFRSFLjSrFhgdZ1FHK6PHTbvF9nReuLQkhcul2tPCm1+V4UYy/Qk7c60IYCQBV8BhIi7p/A2UWGEWV/UsmeS5PCvekjhjnjXqEkE5c5k2bOT9sWM9ubItVFvIBQLbAr3suz/dIOs3XeG52XrbZbj85Vy8/URpjjDExOFEaY4wxMThRGmOMMTE4URpjjDExOFEaY4wxMfSteu0KK7X8ANdFa0eoSWdmWfX68MMPUWzy+AzFtmzeItscGx2j2He/x1Z7n/nsbRRLRrxFaAqFXk/UtOu2hBVSRO27TJa3DZRbl7h0USqzg1PTFDs2ycrTNWNsAzU1oxV2XaHaU3U3mz2Oba7renpXChX0vhpve3h+lmLr107INteIOqZm9RIIKzWl5s4l9KBMCaVjIs37J1M8ndVbrI4FAHRYjR0I+83luQWK5SOs9kbH2J5tYICVuMrtsdvSdnNdoQ4uDorjDA5RTM1bAFCtsco0nxYq+irPE7MzPE4BICteulKe1b25NCtZMwXeDgC64jkuLZS8Sp07JeZHAJgV+aUf/ERpjDHGxOBEaYwxxsTgRGmMMcbE4ERpjDHGxNC3mGfthBBWiIXmRoSoY2SYF6CvvprrRB4+PEmxBx54ULY5OckLy9Ua15RDgvup7OIAoCAsp8aFeKS6zAviSwtLss3jdV5AroqajFNTUxTbt2+vbPPxvfsppha1J9aw/d+hA2zTBwAQ1lZFUUsQFRZ25UQtQAAYGeb6cam1XONvIuDrMTbCYi0AqFXFa2xWLe0cvx9PChu3TkELAYMcD9Zqk0VuswvzFBsvsS0dAAxWeD46VmfBYVNYnjWqWiA0fiGLDgdE7UpV07FSGpJtTh6fp1haCCsHhcCnLmz+AKDT4zm62eDYwjRfj05Tz+/5Is+bSTF3JHOccopCSAToOqTdDs9R8/M8vx48eEC2ubDA4qx+8BOlMcYYE4MTpTHGGBODE6UxxhgTgxOlMcYYE0PfYp7DB1kAkk3zYu21V18r9x8cZAFHUtRU7HR5sXb29ig3BRbzjIyMUCwtFovrDS0IKRV4UXrz5s0UOz55lGJf+MJXZJuPPbqbYpksiwyqNRYD1SNqMvaEOUhGCCQee3Sn2FfXx1wzweKZ8c3nUWxiE9eZ27GGHYAAoCHq3CVyfI3rwgHl4EEWLAFApczCBbN66eVZjNMRwrFuUljWAAi6PAayJRaPLQgxz0heC8IW5nnbhLDLGi2z+1hauAIBQLnIrjNjQszWqLMLT7UWUSdRDNVMmqftgqilGVW3NSNsdJbFtWvWWWCXjnBPKol6mKPDQxQTpTTRjKiP2xHCnZRyL2twP2t1Pb+XRT/7wU+UxhhjTAxOlMYYY0wMTpTGGGNMDE6UxhhjTAx9i3nGxnlRfHCARRWNJi+sAgAWeKG+I1wvlhbY8SYlHBoAoChcdK64/BLeTpRxmZ3T5WIOHGaRjnIbmptj14u9j2vHm9l5drjIipJAaeFkUSqxmAAAcjm1eM9tVsoseti4mcU4APCsq66i2GXn76BYYXSIYtWI8jv/9m+3U2y5y6/n+ASLHkYH9bmPRjj2mNVJW7i5BGlWqWSTonQdgJ4QkFRbLABJdDsUGx1lcR8ATO5n55apoywaLJb5vhzfpNvsCTFQXjhWJQI+n6VFLWgpCoHQwMAQxTJZnjsSQhgJANkMO/sUiyy2LIg5piEEPgCQFK9RQogoux1+jaJIpVg01RYCn54omSbLmwGoN7WQ8Uz4idIYY4yJwYnSGGOMicGJ0hhjjInBidIYY4yJwYnSGGOMiaFv1euzn309xbodtmJqNjgGAE2hhlUKKKXIGhDqWgBIiHqYS4tshdbrsvKsLRS3ANAQdkpHjxym2PTUNPcnqd93DA0OUayY5z6VK2yvVCjoOo+jY6MU234+282ddx7b762ZGJdtnrdtG8Xaqm6mULju3LNLtvnIfrahS6f4PMfGWHVXLmkV5MFdj8q4WZ0kWzzOu8rLTPkyAsiJ9/OqLuGYULimxHwCAM0Wz1PlCqusB8ZZ9Voc4HsVAFpK8S+UsIU8K1mHBrUaM5njeUrVfmyKubjd0rUjVT3MtLCaHBb2e8fFcYCoerTcZrvDfUqk9WuUEUWDO8rOUCh+e109F7dbVr0aY4wxTzlOlMYYY0wMTpTGGGNMDE6UxhhjTAx9i3lUza+UsC1KZ3SThQILODJiob22zHXEhoa0HdHcNItKDh5i4U1e1GrrdrWYR9rqiT4NDPHCf17UWQS0QKkywPuvXTNBsfUbtN3cpZdcSLHztm+n2LCwgZud13Zz87PzFFsUdeo6okhes61rCdaFwEFdj4aoD3pg/x7Z5vKxSRk3q5NEgueEbp4FGO2ktqrMC8u3oniPPzTAgpJmT4/zjBirpQrHMqM8b2WL+vmiU2ehSXuZY2Ux9ssDLPABgG6W+58SRRl7wr6vp8tmoiW2TSZYdDSyhsU8yax+jYYGWSDY7vGckEjxsTMFLeZJKws7YYdYFILHZCrieva0wOlM+InSGGOMicGJ0hhjjInBidIYY4yJwYnSGGOMiaFvMc/Q0BDFVL2ytKizCABBjxdxlUCoWuM6j1G1xTJZXnzvKdeJNC8K94QgBQDyRV68T4p6mAUhRhga4sVvANi0aRPHNrJjzmZRJ3L9Ri3mGRnkftbqLIh5fA8LYpSrEACsXbueYh3wIr+qhbl2TNfoS4Kv/dzMcYod2CfcW1pLss1C98m5a5izQ0o4LOUq7G7TiRAC1oRIJqVcuZq8XaalBXaDJT5+Ujw3dDrCGSfQ/awKceGxA1yjdtvFLMRLifkEAFKipuSymCOLFRa0qHq9ANALRG1gUd+zWGJBTCajRTIQ16QpXNJy4jyzBd3PpjjPrrgeHRFLJfX1rDW43nE/+InSGGOMicGJ0hhjjInBidIYY4yJwYnSGGOMiaFvMU9alEJRparqNVFqBgAgxBptjuXEAvTatetki9U6H78tyueo0i5BhJgnm+ZLsmbNGMU2b2GRzeYtG2Sb69ezcGd0hMUvpQIvlKuFewDYu28vxVpCzCCq/KDZ1qVyUhAlzka5nFd9eZ5ic5NTss2eeD16LX7dZqbZbWd0VAsH8gW9UG9WJ9lBFuO1iiw+qdb13FEVYp7BARazLTb4vloUYhoAGFpmQcuOLVymbnaZBWWzc/OyzY4Yq9NHeVzUhTNOZliXEjw6NUcxMXxwTe5ZFBuKmI9KYlKodvh6JHv8HFUToh8AaAjHnI5wPyskeI5JCsEgALSavH+3w+LAY0dnKHZ48phss1rTTk1nwk+UxhhjTAxOlMYYY0wMTpTGGGNMDE6UxhhjTAxOlMYYY0wMfatelxbnKVbIsXKtkNOKxEyWFYxtobRaXmTlmKq/FsZFXbUc5/5Kheu/jQk1JwBs2shKsc1bWLW6dt0abnNMW9hls2z5tiCu565dj1BsuaqVgIOipl1WvB5Hj7D6q93StSO74PjccVaULc+xBd7uXQ/INtMQloTsHoZcWrxuERZciQjFslmdtJU9m1CX94TdIQDkB1gR2hW1Co+Ke7W9tCzbTPS4Twebuyi22Obxlwh43gGAnDin2el5is0t85hIDvN4BoDltrCQLPAAWr+OvxkwoAYagMVltnFr1blP9Tm2oJue0xZwBWEzumZiiLcT9Sw7Ha3CT4hhPjvFfdqzh5XNs/O8HQCkRV3kfvATpTHGGBODE6UxxhgTgxOlMcYYE4MTpTHGGBNDIgiUyZkxxhhjAD9RGmOMMbE4URpjjDExOFEaY4wxMThRGmOMMTE4URpjjDExOFEaY4wxMThRGmOMMTE4URpjjDExOFEaY4wxMThRGmOMMTE4URpjjDExOFEaY4wxMTxjE+XXvw4kEuHPE7z5zcDWrWenP4r3vz/s47nSrjGmD1b75JNIAO9855m3+8Qnwm337ftR9+is84xNlE8lv//7wG23ne1eGGOecXjyeVpwojyJv/or4NFHn/h+P6p79b3vBer1p75dY8wqY7VNPv3wC78QTlBbtpyd4z+NpM92B54ovR7QagH5/FPfdibz1Lf5w5BOh//i+FFeD2PMSTyTJp9+SKXCf88AztoT5Yl1sp07gde+FhgYAEZHgfe8B2g0VrY78XH53/4tcOmlQC4HfPGL4d8OHwbe8hZgzZowfumlwMc/zsc6dAh41auAUgmYmAB+7deAZpO3U8sEvR7wp38KXH55OD7Gx4GXvQz43vdW+letAn/91+H/E4mwnRPs3AkcOHBqm3fcAfzczwGbN4f93rQp7NPpT49qLTHqeuzbF/7tj/4I+JM/Cd/kFQrAjTcCDz0kXoDTuPlm4EUvCq9PLgdccgnwF3/B223dCvzMzwDf+hZw3XXhNTnvPOCTn+Rt5+eBX/3V8PxyOeD884E//MPwmhpz1ngmTz67dgGvfjWwdm3Y5saNwOteBywscJ9uuw247LKV8ztx7idQa5QnJogvfxm46qrwGJdcAnz2s9z+OcRZf6J87WvDa/uBDwB33QV85CPA3NypE+/ttwOf/nR4z46NhdtPTgLPec7KvTw+DnzhC8BNNwGLi+EEDYTJ58UvDu+Xd78bWL8e+NSnwjb74aabwvvh5S8H3vpWoNMJE91ddwHXXhu29da3hknjF38x3Gf79pX9L744TFYnr9vfcgtQqwG/8ivh+LznHuCjHw3H1C23nLlP6nqc4JOfBJaWgHe8Ixzzf/qnYQJ88MFwTEfxF38RjoVXvjJ8iv3nfwbe/vZwrL7jHaduu3s38JrXhNfmTW8K54c3vxm45pqwDSA8vxtvDOeTX/ql8E3Bt78N/PZvA0ePAh/+8JnP05gfKc+0yafVAl760jBRv+tdYbI8fBj4l38J39UODq7s+61vhcnt7W8HKpXw2rz61eG5jI7G93vXLuDnfx745V8OJ4ibbw6fDL74ReAnfqK/c19tBGeJ970vCIAgeOUrT42//e1h/P77w9+BIEgmg+Dhh0/d7qabgmDduiCYnj41/rrXBcHgYBDUauHvH/5w2ManP72yTbUaBOefH8a/9rWV+JveFARbtqz8fvvt4Tbvfjf3v9db+X+pFO6rAILgxhtPjZ3o28l84ANBkEgEwf79K7ET1+j09tT12Ls3/FuhEASHDq3E7747jP/ar8W3q/r00pcGwXnnnRrbsiXc95vfXIkdPx4EuVwQ/Pqvr8R+93fD6/LYY6fu/1u/FQSpVBAcOMDHM+Zp4Zk6+Xz/+2Hsllv09ifvl80Gwe7dK7H77w/jH/3oSuzmm8PY3r0rsRMTxK23rsQWFsLr9axnxR93FXPWxTynP628613hz89/fiV2443h0/sJggC49VbgFa8I/z89vfLvpS8NP0W4776VdtatC5+ATlAsrrwBi+PWW8M3je97H/+t369XBMGpT5NA+JHoCarVsN833BBu+/3vn7nN06/HybzqVcCGDSu/X3cdcP31p15Pxcl9WlgI+3TjjcDjj/OnMpdcArzgBSu/j48DF10UbnuCW24JtxkePvX1eclLgG4X+OY3z3yexvxIeaZNPieeGL/0pfAjnzhe8pJTn06vuCL8iPrkQR7F+vXAz/7syu8DA8Ab3xhObseO9df3VcZZ/+j1ggtO/X37diCZPPVj723bTt1mair8pOBjHwv/KY4fD3/u3x+ujZ1+b1100Zn7tmdP+JqPjJx52yfCgQPA//yfwOc+F37SczJqqeB0Tr8eJ3P69QSACy8MPz2K4847wzH5ne/wGFpYOPVTmc2bef/h4VPPZdcu4IEHwiSqOPH6GHPWeKZNPtu2Af/1vwIf+lC47vqCF4RrLW94w6kDHOhvkEehzvnCC8Of+/aFH/meY5z1RHk66s3SyU87wIoY5A1vCD8CV1xxxVPbr6eKbjf8mH52Fvjv/x3YsSNc5z98OFzn60focvr1+GHZsydcStmxIxxDmzYB2Wz4hvhP/oT7FCV0C4KV//d64Xn+t/+mtz0xboxZNfxHn3wA4I//OJxo/umfQsHNu9+9ska7cePKdv0M8mcQZz1R7tp16pu23bvDezHOpGJ8PFxf7nbDTwji2LIlVH0GwanjoJ+vLG3fHn5KMTsb/8buibjcPPgg8NhjoVDtjW9ciX/lK/23EceuXRx77LH46/nP/xyu73/uc6e+kfza1558P7ZvB5aXz/z6GHPWeKZNPie4/PLw33vfGyrsnvc84C//Evi933vibSl27+Zzfuyx8OdqcR96gpz1Nco///NTf//oR8OfL3959D6pVCjAuvVW/dWHqamV///UTwFHjgCf+cxKrFaL/tTkZF796vD1/p3f4b+d/MaqVAo/jVGcrtA+8Ubt5P2DIFSnPhXcdlv4dHqCe+4B7r77zNfz9D4tLIRitSfLa18bfoz7pS/x3+bnQwGfMWeVZ9rks7jIA+/yy8OPm9VXVp4sR44A//iPpx73k58Mvy5yDn7sCqyCJ8q9e8OPyV/2snBi/Zu/AV7/euDKK+P3+4M/CJ94rr8eeNvbwvX22dlwHf2rXw3/D4R/+7M/C5/e7r03XFv/1KfCNfUz8cIXhuYTH/lI+ObzZS8L33DecUf4txN2iNdcEx7zQx8KlxW2bQv7BbBCe8eO8M3ib/xGmNAGBsIx189H//1w/vnA858ffvWk2Qy/hjE6Gv0RKAD85E+GH7W+4hXhVzmWl0OjkImJ8KscT4bf/M3wCfVnfmblqyPVavhE/ZnPhEsVY2NPrm1jnhKeaZPP7beH+/3cz4VrH51O2J8Tyf+p4sILw6+2fPe74XfSPv7x8Cs1P8w777PN2ZLbnlBoP/JIELzmNUFQqQTB8HAQvPOdQVCvr2wHBME73qHbmJwM/7ZpUxBkMkGwdm0QvPjFQfCxj5263f79oRK8WAyCsbEgeM97guCLXzyzQjsIgqDTCYIPfjAIduwIFdPj40Hw8pcHwb33rmyzc2cQ/NiPhV/NAE5Va6uvhzzySBC85CVBUC6H/Xnb21bU1zffzNfoZKKux4mvh3zwg0Hwx38cXpNcLghe8IIVtXtcu5/7XBBccUUQ5PNBsHVrEPzhHwbBxz+u1d8//dN8/Btv5PNcWgqC3/7tUA2fzYbnesMNQfBHfxQErRa3YczTwjN18nn88SB4y1uCYPv2cKCPjATBC18YBF/96qnHjTrvLVtObT/q6yE//dNB8KUvhRNKLhf2/0xfSVnlJILg7KzOvv/94acKU1N+sngq2LcvfDP5wQ+GT6vGmAg8+fzo2Lo1dPP5l3852z15Sjnra5TGGGPMasaJ0hhjjInBidIYY4yJ4aytURpjjDHnAn6iNMYYY2JwojTGGGNi6Ntw4HtV/oR2qdmW21ZKWYoFtSrF7vnO/RTbtUd/w33tBNdA27BhHW8XUXRxcHiQYqUS2z8lhcVhs6FdK7JpsX+S33ss1vnatSOcaUo57kAmEAawXW0Kmwq44XRSHB98nF6Ev2Ozy7FOT1hndbSdlupqvcWN9sQiQCqtb1F1nW9cLzc1Zxl1pwbgFztQNwCAdqdFsZaIVfIDFEtEeSeL2+qHXYN6EmZyqwYxxCVR56ifuNQVVTG9t+pT/3treuIeyyTP/Mr5idIYY4yJwYnSGGOMicGJ0hhjjInBidIYY4yJoW8xT7XHwp3F5pLcttHNUKxVa1BsZpZLZhw5UbfsNO69c4ZiHbG0nCuyaAcA1q9nkc9FWzh24cXbKHbedq0SyZTzFEsk+Nwn8uL9SDdKOsBinEBUc86oNgH0hEgoleI+5YUYphkhpkgk+fhNIeRqRy3Kt7hThSTfeqm0EIH1tMygLb/+G1Fs1pxVelJ4xmN37kTVjdP4/sP/TrHt559HseK6kjhKxLNA5Pg7lWp9mWK1ak1uOzhQoVgqwfd5Jsv3+dmm16eUKerJqidezyBCxnU6UYKrQNTaVHpBJQzrijkTALpdnk+GcjndgZPwE6UxxhgTgxOlMcYYE4MTpTHGGBODE6UxxhgTQ9+m6HcssLNOhjUiAIB2mxdMO21ehR3M8iJqKa1z96FDUxSbna1T7JFHdsn9//Wfv0Sxxx/5AcUqgywGWrtRu/1s3rqRYhdcdCHFdlzAAqFNG8ZlmxNjw9ynIi/+JyJWwAPh4qPcbXIZvs5tIboBgJ4QPqSEGKgVcSt1hEhIGAghLd63Neva/amd4mty8Zjf961GOuL+OTZ5jGIPPfiQ3P+W2z5Nsbe89S0Uu+TiyyjWa+txMlhhF59ACD3uuPMOii0taxHjC254PsVKRRYYpcXEmRDClacTKZkTc0niidgXieGYUkO0p0V4So/TFvu3RD87ESJApVkayUYkspPwzGKMMcbE4ERpjDHGxOBEaYwxxsTgRGmMMcbE4ERpjDHGxNC3hV1zmTdtJ7UisVgs8IFSrExaqLOtXS2hFVDFMqvHjh+ZpNienQ/L/avzxymWL/CxlqpsWTX9CKtrAeDhhw9Q7Ktf+DbF0kVW9w6I+pgAsGXTWopdeP5miu24iC28AGB4tEyxmlAdDpT5+Fdt00rccrlIsXnRZkbUvQSAlHg/puytEgneLpvRt+i5XPvvGUfACsSZGVax3303jx0AmDzONWoPHTxIsUKO79OlZR7PAHD1lc+iWKvO4/yuu+6mWLul69O+6IUvopiyq+sJOWeU6jXRR63Ep4KE8L5MRdSn1fDY7zT4elbFNW4t6teoMs7WoT2hGO4IKW6EG+eTVhf7idIYY4yJwYnSGGOMicGJ0hhjjInBidIYY4yJoW8xT0vUVYuq6RY0OK4ycqclFmE7LdnmY8Le6l8/+48U++63tSBgeXGRYoGoX5iqjFEsPzgi20yKsyrleLF5ZGSIYnML3B8AeHzXHood3Mdihq/d/j25f2mAxQPdHMcaNRZircloC7vnPv96il10zdUUu2rHBrn/QIlFFu2OWoDv3zLLYp5zh4d+8ADFPnfbP1Hs8NHDcv+BIt8/08dZyDco7Cdv/9o3ZJvr166j2PjoKMWEvgyHj/J4BICFhQWKFfPc9ydCIFQpPxKBT5fn3UO79lJsbmpa7n7oEL92j+1hO9EZsV11fl62+ao3vpViV77wJbyhsj2NuER9OrYSfqI0xhhjYnCiNMYYY2JwojTGGGNicKI0xhhjYuhbzJPssvgjE1ETsSjyb0JZJQgXnnyJXX0A4Oorr6TY0tQMxfY9rGvaNRd523SZXWzKQ3mKFYRABgB6YqU/meZzSmb4OmUyul7a8iK7FSUSol6aEL4AQHuaF+VzBd5/aY7ri+6fnpdt3vP9fRR7/evZTeP6Ha+X+ydFV4MOC4cCUeOy3dUCo6QUfbF7kzn7/N3f3Uyxo0e5HmUqqZ1g5md57D58PwuEjk+y289DD/F2APDgQw9SbONadoIZEgKhtKjvCgA7d+6kWC7NY294hEVDTy88Fx96fDfFPvjb/y/Flo5rMc9cneeTlHDRyYman0lVJBLAv3/3Loo968Us5ukJ5U4y0M+Aql5vP/iJ0hhjjInBidIYY4yJwYnSGGOMicGJ0hhjjImhbzFPr8GLoKKCDABgeIAX5bOivMnULAs1DrPhBgDg0CQvFj96iAVGw+sulvsvLCxRbHmZF/9r7XmKNea1SCQosGNPJ8lipCnwAni5rEVLuQLHW80aHzuijkxSOCgtiTJFav9MZVi2ed11l1Pspl94BcXGKxW5/8Iiv3ZKUKBi7Y4WPRWE8MesTu77PpeqOv+CCykWVdZpYSeP0x0v+QmKLdVYCFfIcYk7AKgIt59CgWO1GpeFSkU446wTbj8ZUSYuJe7d3hNwjAkiHNFou4g2Vampxx74d4pNCYFPvqfHXTbgubhSZGFkVpTXCyLK8zVbYt4Tc4TqURBhzaOEP/3g2cYYY4yJwYnSGGOMicGJ0hhjjInBidIYY4yJwYnSGGOMiaFv1Wsi4E07LVY6AcDiHCvFcilWKx09zvsfmI9QK6XY9unyG1j5NiFsqABgdpYtsw4fZVVXQdSPy/S0ck5Z+CWFEjghrLmqwqoOAHoBX7t6g7ftdrUVU0LUecwKF7icsO+75NILZJvvfNfPU+z87XydE22tXsumhAVfjzuVEOq3ckFf+6SwPzSrk6njbEGXzeyj2MQ414IFgEqRVecLc/MU237xRRTriXkHAI6JepbNRpNiF1/CKvq8qO8KAHd+hy3Xnv3cGyl2XpFt8So5fT8/XXVXu02ed0p57lM5rcdjUOPrvCzqTE4IJWyvreeyZfEadVtsnZnO8/WM0gUnrXo1xhhjnnqcKI0xxpgYnCiNMcaYGJwojTHGmBj6FvOUAl4ETbQjFkZ7vAgcpHjb0RIviifSus1UlgUh3R4vDC/s1SKZ4fEJim29+DkUa/XYMq3Z1DZqnbaIt3lRvCvs4rodvYDd6XFcrXVHLVYnunz9AiF8ufwyFim851f+s2xzy5pxih2ZXuBjB1ECG473lAVfW9Q8zej3cglhmeV6lKuToQqPvUyCxWT1mqoxCpy3ne3uJtauodhznns9xUbW6NqPY6NsN4cezzEX7thOsUsuPE+2ecttX6TYX//Ltym2ffOjFHv2ZWtlmxeO8nkenV6k2Pz+fRQ7PPkD2eahQ2ypuffueyg2PcfWgXMR47GYZfvLTsCCvfk6z49DuSHZ5uSBgxRbnmE7zrFNLObpRtj3BWJ+VfPT6fiJ0hhjjInBidIYY4yJwYnSGGOMicGJ0hhjjImhf2ceURcwm9aClJywglFmFrk8719o6jZTWXbMaYgamTdcdZnc/8rzt1Jsz5EjFNu3dxfFJo/tl20eOcb7T07zAvjCDNdjrLaFXQ6ArKhfB7GtEv0AADJcz/KKqy6h2G/91psodvXl22STC8JpCQl+QTvCqQgAMkk+p17A95OqyZeOuEWrovagWZ1c9azrKPbCG19EsaXqnNy/mBMuUhfzPV0pcn3YLZu029SWTXyvq1quPVE/MZ1mESEApIRAbXbn/RQ7+K0DFPtSg4UrALAuzQK16gIL6Vqz7FhTTesx0unxeY4l+ZxGB9l9a3JeFwwOOnx8ZPk4i6KWZkq4vgFAq8t9OjrLIr7xjbxvUohPQ+zMY4wxxjzlOFEaY4wxMThRGmOMMTE4URpjjDEx9C3mmRXiiUxSl9kaLvMibLfHOTkp9q+UtUtCXbjgdMTieb7Ioh8AGByuUKw8NkCx5zzrfIqtH9dtzi/xovonPv1Zin32M+zYUV3ULiQ9UbosKQyAMil9nS6/jJ1E3vvrb6PYs7ZtoFh6eUm2ubbC164t3mO1pFsOkBD9bwmBUinLAqF8UZToAnCk83QVIDI/LM+5/gaKXXThpRQrlHQJp5RwfBqfYLeoTI7vlWREWah0krcNhACkJ0Rz1aoWydz77TspNvnIwxSbyPBxUhkt7mumWAg4ARbXtUss+ukO8xgHgGaVhTfJLl/jBWEJlsiyUxAAzNeOUywrBHslIcqcb8zLNitFFlx9+54HKXbFpSzgTESIeYSWqC/8RGmMMcbE4ERpjDHGxOBEaYwxxsTgRGmMMcbE4ERpjDHGxNC36nW0wCrNYlYrLwfKwt5MqBzzaVaeFUTdSgBICgu9XqLJxxE10ABgcaZGsYyofTkyzBZwlYir9JW7uNbcd77xDT6O2DfiNFFrCHVxmq/nlZddLvd/76//EsV+7Equ55ds8LVrNLRqtdFj5d1ilxVxSzVtYReIGpnpBF+VlniNS4FusxlhdWhWHxNrRU1IIYWuLvMYBYBCjpWSygJR1RXU9QeBpKjoGiRFrMdj4oGHHpBtzkyzvdt4hcfuqKh5O9nScynr6oGuUKc3xFTeEucDAOUmj/1eicdjr8wWdpXimGyzNbeXYgsHd1Is1eQzKg0If1MA3cV9HJs6TLGEqm0bYVWnbDL7wU+UxhhjTAxOlMYYY0wMTpTGGGNMDE6UxhhjTAx9i3myYhFUm0MBi7PzFKuLtfdykVs4OiNqHwKoCce3LDjYFGIYAKi3uP+Do2xhd/jgDMX+6ua/k21+4atfodjs0iJvKOzWlLgJADJC4HTlJSzGef9vsGgHAK6/grdtC6u9oaFhirUihDPT02x5lc6yTeG4sKcCAOT5/Vijw+cfgG+Sxbq+H1p1tSiv6wSas8s37vgyxV75n15HsZ6wTAOA+cVpio1McI3KXELYZCa0VeTc3CGKlQbYBq7ZEqK35qxsMy2sO+tdFgO1hZgnPbhWtllcz/H6gUcptuWiayjWTA3KNtt7vkOxicvWUWwpv5W3W8fHAYDj08co9vh9LGw8/hAfu1YXcyaAdW1h31di0VNKCHe6QqwFAF3xeigR2On4idIYY4yJwYnSGGOMicGJ0hhjjInBidIYY4yJoW8xT7InXHAaWmgxMsgimWSGhTvHZlhkMldVjhvAcoPFH7mAj1+raXePWpsXfPfs3UOxr3/z6xS7/yGugQYAtRYLBepCuNMSfU9E1JO85opLKPab7+J6klfu4FptALBc5z4tC+FLCyzQySS1m8WwEF0VKvwaN4VbDwA02/w6VUSdyaI4ztIS9xMA0v3fuuYsc3yGHWvqNR7799zzXbn/DTc8h2Lf/g4LRZ73PN7u7nu+Jdu885u3U+w1r3sNxb55990UGxzQIplLn3UlB8V01Dm6j2LHFrQ0cqOo2zklHm+yoj7n8oJ+Djq+wNc+3eTjz/dYMDWS0/NWfoRdfC798Z+jWG4N18vd/cDXZZtBg8U83TQLpu76Dr/GW88/T7ZZFLmpHxGgnyiNMcaYGJwojTHGmBicKI0xxpgYnCiNMcaYGPpWRNTr7HiTiti722TxRrPOq9rdJrfZiHDngHTd4M3SaZ37//2++yj2zW/8G8VmptkFZEG57USQFY41iTwLVy6/6AK5//v/+zspdsPVl1FsepKdMACgleCSNS1xneptvvaJrH5Bu2Ah12J1jmLNiNtJVcFZEvfDQCDKJInzAYBmS4m2WHxgzj7VJXZDueNbLJJ56OH75f6pDN9Xux57jGIzM1MUO3xgn2yz1WDR26M/YMebhXke+3Mzej4o5Vnks7jELj5VUWoqnWIxDgBM7d9NsXKPjz+z5y6K5Yd43gCAUpkdtOpT7EjWEkPvvjs+J9vMF9hBaO3mHRTbcPGzKVYZZ1cgANj7EJcxvOcRft33Hj5AsdEH1sg2N2zZQrFXv+r/kduejJ8ojTHGmBicKI0xxpgYnCiNMcaYGJwojTHGmBicKI0xxpgYEkEgCk0KvnwHK8IGogpStllRls2xhCov1Fe7Dh2XTXaTrBzN9lj5WFvWFnZ33sc2dPfc+z2KHTzEderm5lgRBgDJBMtJU0lWbl551VUUe88vv1W2+dyr2cKu22bVaautX7ZGixWGtQZfkzWjFYqVS1yPDwCqNVbIziyysrnR0u+7Wj1Rj7LJ/V+sstVfKqtVr2vKfJ2fe6Wu6WfOLj/1ytdSLJnie0KUYgUABAHbWuYzYuMO3/vFgr5/Nq/je6U8xKrpgXHerqNdNjF/lNWou7/DVnnJOltnNoLNss1ihg+2rcjzUZDksbN3caNss17lfuZzPMbraR5jVegXaWmZX89UeYRigxu5Xu6ajRfJNrtNVtajzvPzpjG2pdt3lLcDgLkqW2J+5u9vk9uejJ8ojTHGmBicKI0xxpgYnCiNMcaYGJwojTHGmBj6trBbEnUie92IPNtjG7pSivcfKfDhL1yrbciaLW5zYZ4FITlhFwcAL7yGa8XtOI9rOu7ez3ZIux9nGykA2L+X4yMVFii94w3/iWLPvZStlACg1+SF9rYQR5XLLMYBgHKOr2k3K1RXbV78XzjOdlsAkMqwIKKilBfSVg5IdPhY+Rz3KZUU91NG179LJvvSoJlVQDZdoFhSWFImwPcJAKRU7VbhdJnN8dzRaWnlzeP7jnJQ3H7d1F6KJVJaIBTM8f2fmmGryZQqUgktGBwr8Ti/6gKu6bjQnKfY/u/p8Rw0WfTUFpZ+hZwQXOX1GB8c4H4uLjxOscxhrjE5t8DWgwBQbbPwZvNmFghlc8MUGx3mGACkhKi0H/xEaYwxxsTgRGmMMcbE4ERpjDHGxOBEaYwxxsTQt5inlObVc1VjEgCKZa7JuCTqWR6d5AXsgQgxTlPsv7jAwpeBgYhF3DQv6mez7OiwZoRrqL3gWeyWAwBLs7wIPVpmkcoVO1g0NJjkBXUAyOZZkFBr8jWZmRSuFQCyGX7vMzLI59kRYoggQowDIcZRdT+HxiPqQQpxV7PO579Q49dosbkkm1xoqrqluq6dOcsE/FonEkKgE2ESlurya63uv45w5uklIux+wMdKJvk4XXHvd8VxACAVsPgkLcQjXbALTz6nXbGOLnGbX9rPc8xiiwVT4GkYAFAq8zirCqetwUEez6miKG4L4MAMC4eCFPdp6tARirUhhFUAenk+z5Ehvp5Bgl/L9Ru1K9FoR/f/TPiJ0hhjjInBidIYY4yJwYnSGGOMicGJ0hhjjImhbzFPeWkfxVIddnMAgFxPuK6IxfNGjfN0PaJ8VE8soA8L4cpAggU+ANDqcamqbEI4xgiNQTrQ7jBb1rJwSO1fP86L1cfmp2WbiRSvwHeEA9LCohbeFIR4YHmKRUeBWNNOR7ngCBeepBBTdJf1QnnQY/FAVyyqN5b5flqqauFEIO4nQJfrMWeXuUUWZGVSPPVEVfxLinFaFEKPZluIeUTZOwDodXnbbJa37QkxD0R5PQBICnFjKSNcidIs3BmssOAOALIY5cOXJyiW6w5SrFJigQ4AHJtlQU2jwGN8VpTXS/E0CgDodXneqjd5/2PHuYxiocBuZgDQbvLBihV2ANq4hcWS3a5+3WfmtTjwTPiJ0hhjjInBidIYY4yJwYnSGGOMicGJ0hhjjInBidIYY4yJoW/V68wUqzSLJV3bq1zhZjvCxmp6hlVis3OslAKAkQFWj5WFVV53Se+fTrDyspJhpVeQ5nNqd7Uar13n2mqqUJ7auxehnINS6aXEthFqvmaNlW5tJfRKcD8T2Qg1X4bjSWFB1oXeX9mVtUU9wiNCybuohdWYKPZ965qzTEa81skk3ys9YVUHAAl5ryuFKo/9bET5QWVNl03xSO2Iuq25gvaGy4p4UXS9JaaoxgJb1QHA0OAQxWrCzrOiSnZO628AHD54kGLTQlyeFvVhs0LtDgCzYuxmcjy/qtqi3YjntaUat9lWr0eelbAtaXEJVCpRlobx+InSGGOMicGJ0hhjjInBidIYY4yJwYnSGGOMiaFvRcTDByYpNljSC6MbGyMUqwhvt4WZBYpV6yy6AYCOsMtrtXhht1wRddkADBTZJqkkRALJDF+STDLCVk8KErj/gTilVCriPYqylhML4D0pEQK64mCBEg6JkOo7ACQSbBcm9BnIRpzTghBDHVpihVFdvJ6VnL5FC6kntyhvnn6yXRaqZIVoTtsSynKmstRiUQQr5Yj7RDjTDZVZFJLNc6Mjozy/AUCryUK62eOHKbb/33dSrAI9bxU6PCbz6zdRrLbM42n5OFtXAkBK2Fxmc3zts0lx7YQdJQCUKzy/JsW8kx5hS76hkTHZZuMYW3+Or1lLsbqoYxuhv0SnE/GHM+AnSmOMMSYGJ0pjjDEmBidKY4wxJgYnSmOMMSaG/utRCteKknKMAVCdneVggQUhg0Jgk81oK5Zul1ffu212qKgvakeGoMULvq0iL2qXS7x4n4uo06g0Mr2Aj68cRxK9/t+jtJPinCJq9/XA59kTr11PiBmEqVAYFuv3vQxfu0ZHN3BggR02mkJNVBT300hSiwdSbV2P06w+rtjC4pfBoSGKqfqDAJDK8dyRF/NJJc/T2ehAWbbZFceqVVmMUxIilSgWl0XdzC0sVJmb5dqTpbYWHR16bBfFjhzeR7Fsm8feZiFOAoCmmM4qw3w9S2J+np6ckW12hItONscCpVyWY4tVXSNybGKcYus3bqZYEPBc2hEiKADoRbiHnQk/URpjjDExOFEaY4wxMThRGmOMMTE4URpjjDEx9C3mGSzwCnAqwkkjEfCCabPJi6vJJAt3KsI1AgB64MXuTov3TwRaDBR0uE+1Km/bbvMifyGrF9rTwplHltkSwh3lbBNFTzjWRJHM8uvUESKbRFqUQotos9Xm61Sr8XWabeqTSqT4WBVRumukwNc529Ovp3L9MKuTy85jUUalokU2iqUqO/ssLbBgsLvIc0yzq0ti5bJCvJLl+Wy0zP0sixgA9DJDFDvc5L7v2sXjpDsfIWQSdbqabT7PmSU+zoY1fN0BYPoou6zlhAix3WDhzfFpIdQEUBaCq3aHz7MtREdzc7oc2NoLzqOYOveWKJnWiXAZ60SUcjsTfqI0xhhjYnCiNMYYY2JwojTGGGNicKI0xhhjYnCiNMYYY2LoW/U6vcAqoqGIepSFLOfflKr9KOzWEl22pQOAnKhfVxAWdJ1OW+7fE2rYAKzU6onid82WVqR1hPJSKYE7sjiafo+iak9KgWdEWbV5oS5eEBZPvYRQj0UUcau1+ZomRD+zCa2brQgPvLU5tsfKi0uiahGGPLm6cubpp1abp9jc3DGxpVYyp4WFY7nE98/oKNcqHF8zIdscHh2mWFbYMtYabGs3N6Nt3B545DGK/eDwEYodPX6cYuuKa2Sb3QRP0a0292myOkex6bq2htu+getZzlUPUiyprDfFNxoAAMpGTuwfiJq111x3nWzykf37xGH4+F3xTYOOKgIMIIioLXwm/ERpjDHGxOBEaYwxxsTgRGmMMcbE4ERpjDHGxNC3mGfXIV7AHizrWm2DBc6/60fY9iktBDoZYW0GAN2ABTVdYUuXTWuBUUcIBYKEEKSIxeaEEB0BQCIhFoaFaCkt61bq81TCn0aTRTKHDrFIAACWkmzZlRhZR7FAdSqt3zdl8vw6ZcXrMZzWYp51wq6sIAQaPWE7pep7AkDQ9Xu8c4WFepViIyNcp3HDxg1y//O3sEhnZHiUNxS2jHVRhxYAjs9MU+yhh+6j2GExzh588BHZZpDkezJX4lqcl19+LcXWljfKNu+a4j7lWtynhrBxa0SIEKtLLJhcmJ+iWDvDc2mqMCTbBHiOUMJINcdccOEO2eL3d3MtzlqdhUyZjBBlRhXX1aWFz4hnG2OMMSYGJ0pjjDEmBidKY4wxJgYnSmOMMSaGvsU8SPHC7kJdu+DUGiKeEC4P2UGKdYTjC6DXYFPKsiai0GM2zQu+OeEglEmzmEZofgDoxftkhsU0Cy1uc26ZF6UBYKnGi/JTU+ywsVDTYqDCUImDTV7Uz4vrPFzUtfsynRrFcl2OrS1z/ToAKOeEg5GoUSn0CGhF3GOtJ1Cj05xdXvGzr6bYxFqulVjI6YFWrfJYOXrsKMV2PraHYrff8V3ZZmGgQrEHHn6IYhvWs8BoZMN22ebWzVsotn3zhRRbEvfu7gcel22umWDHnlZG1NHt8RyRzWgXmk6b563hCe778iLXuBws8JwNAGlxPQ/NCwcjIc77p3/+J9nmUpPP85t33Emx8RF2WbroEi0QGh5jcVU/+InSGGOMicGJ0hhjjInBidIYY4yJwYnSGGOMiaFvMc8QGy+gF1FxpdnmBdvpJXbnUC48QY8XhQG90J8XsVZbO3GkwIKWREoIQpSzT4qFQIB20Tm45wDF9izw9ViOuHiiohUKeSHQKek+7Tq4n2L1Ji/0P/fqqymWWuLFcwCopPg8hyvcp1aDBT4AsCDERMUy758QJXRSEQ5GmQjRl1l9DI+yAOTwFJfZOrZXO97c+pW7KbZ/zyGKrR3me+rgjC7bd+NLXkaxn3/dcym2Zi2LafIFLXo7tJvFRAf3cUmtH0wvUGxpUpfuGmkt8vEDnkuv2cz9nGno8TwrxC8vuP5FFCscYweg2T07ZZu7mzz2e2I85zOccqYW+RwBIFcZoNhSjeeSwUGexxOyNiGwNMfXvh/8RGmMMcbE4ERpjDHGxOBEaYwxxsTgRGmMMcbE4ERpjDHGxNC36rVUFhZwKV3zqyos7Dpi05awKKous6ILALot7moCrFAtibqXAFDIKTUrKyfnu3yc6Vlto3bsGNe0mz7Ksdwg19NrNbQF28wUq+QuOG8rxRKBtqdKtVkVdvE2tqfKNllpFlS1Si4zNMRBsWkmpZVmSVHjs1lnNWJSKNXSwuoOiFa1mdXH//rYxyl25z0PUGzdqH7ffnielewb1nH9xmuvuoxi/+l8jgFAcYjHpDp6tco2brPzrCIHgMoYK08rwzzHDF0iVOwtPcfce/sXKPZvd3ydYokezydDmzfLNscuuYhiX/42W8MlDrOCP9fS83NDqOBnxFy+fs0ExTIRKuJckdvMCNvQzZs3USxqdkgJ1W0/+InSGGOMicGJ0hhjjInBidIYY4yJwYnSGGOMiaHvlc0DQqSybS1bDAHAxBALapJpXtTOJEUsHWFZJnqaSPIif6+rLavaCfbgW2jy8ffP8QL0fF2/n0gkRymWGuGF6WPTLNBpCMsnAMgX+UTvf/heig2Wi3L/teNc5y/f5YX+oqjwOTao20wGrNwJuuKaCNEOAHRFoUlVj7LbYYFSo6Vfz0T6yS3Km6efe77/IMXKw1wX8KprniX3f8lWrum4Zozv87SoddgMtNXjUo3FMz0hiGnWOZYUtXkBoNkRghzhtNjpCmVjWo+d0Yv53OtFtqBr1tmaLR0xvS8eOEyx6cM8R2F5SrSpBX+9GgucggQfv1AXdXiz+noqS8tSnmvelosi34h9ASCf0ffDmfATpTHGGBODE6UxxhgTgxOlMcYYE4MTpTHGGBND34qI5SoLLXYdmJPblgu8gj1cYZHLyBAvzBbyEe4uaRaaNFvcp9qSdrxpLLATzUxbOEKIhfpCgfsJAEGPF+W7Te5TMskL4ANlUeATwJpRdvdoixpsPW3kgXyCF6tbSywcWhaXuShcLwCgkufbJAhEDThVyzP8Cx+/xiIdVUu0q4QPALI5v8c7V3j9m95GsZHxDRTLRvip1IQiZrEuxHAdHmediGeBhFAHqlutm+TtOh1d87YrptOkqDubEyLGphhPAKB8cHp5ngsbNXYQOnzsqGyzl+W5MN3hPnWF4G45op/ZHl/nhBBXLYgamZUK1ysFgJQQ3owLsaK6axIR91JD1MbtB882xhhjTAxOlMYYY0wMTpTGGGNMDE6UxhhjTAx9i3mSaV7E7USIPxppXoRdFGKcboe36y1q54d0VThkZHkBOsIcBkFKLEIn2SWiF/CieHNxRjfaZeFOp8WLxeUsn2c6wlmmKkRH68fZAahW1Y41S0vs0DEoSuC0e9z36YWIEmcdFj0VhdtPRdwjADBQqVCsUGAxU1MIfJoRi+/5AW7TrE4GRriklbp9FyNEMi2wck0O8y7fU93IgkviWCKUEIKWIKpNIV4p5XjeK4Dng9oCO58BwIHHD1Isl2fRXCPL/ez1IuZS4V6W6vD+7UA4nwlxEwAELT73pBD39cT1TGa0CDArHHuGhtgNriecvxpVfS89WfxEaYwxxsTgRGmMMcbE4ERpjDHGxOBEaYwxxsTgRGmMMcbE0LfqNZNlpdfgMNdFA4BcmRWJyTQr0hrKckoLJ5EQtd6COu+filCkZTP8niCVUvZorAZFhBovl+FzSord00IFnImwe0sLC79Gle26Boqi0B2AcoVfE3VJl4UFWDNCzJfK8kl1Rd3QpeOi1hyARaFYHh8ZolipyArBUlHXj0tmtQWgWX0sLvM47QnlZ/AE3rcrNWsqoWzU9DiBsJaD2F8IP1ES9Q/DOFtdNhZ5nB0/PkmxXXt3yzb3PPwoB0Ut27yovxh5PcVJJdW5CzvPdMTXCspZYUdaZLV8WozxREK/RsNDbG1XLovak3JvTTIVcT+cab8ntZcxxhjzDMGJ0hhjjInBidIYY4yJwYnSGGOMiSERBIGQnxhjjDEG8BOlMcYYE4sTpTHGGBODE6UxxhgTgxOlMcYYE4MTpTHGGBODE6UxxhgTgxOlMcYYE4MTpTHGGBODE6UxxhgTw/8HP0M8ClMKhfUAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 640x480 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def visualize_model(net, dataset_val):\n",
    "    # 加载验证集的数据进行验证\n",
    "    data = next(dataset_val.create_dict_iterator())\n",
    "    images = data[\"image\"]\n",
    "    labels = data[\"label\"]\n",
    "    # 预测图像类别\n",
    "    output = net(data['image'])\n",
    "    pred = np.argmax(output.asnumpy(), axis=1)\n",
    "\n",
    "    # 图像分类\n",
    "    classes = []\n",
    "\n",
    "    with open(data_dir + \"/batches.meta.txt\", \"r\") as f:\n",
    "        for line in f:\n",
    "            line = line.rstrip()\n",
    "            if line:\n",
    "                classes.append(line)\n",
    "\n",
    "    # 显示图像及图像的预测值\n",
    "    plt.figure()\n",
    "    for i in range(4):\n",
    "        plt.subplot(2, 2, i + 1)\n",
    "        # 若预测正确，显示为蓝色；若预测错误，显示为红色\n",
    "        color = 'blue' if pred[i] == labels.asnumpy()[i] else 'red'\n",
    "        plt.title('predict:{}'.format(classes[pred[i]]), color=color)\n",
    "        picture_show = np.transpose(images.asnumpy()[i], (1, 2, 0))\n",
    "        mean = np.array([0.4914, 0.4822, 0.4465])\n",
    "        std = np.array([0.2023, 0.1994, 0.2010])\n",
    "        picture_show = std * picture_show + mean\n",
    "        picture_show = np.clip(picture_show, 0, 1)\n",
    "        plt.imshow(picture_show)\n",
    "        plt.axis('off')\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "# 使用验证数据集进行验证\n",
    "visualize_model(net=model, dataset_val=dataset_val)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1036929-819c-4972-8aa3-cef84ed8e05c",
   "metadata": {},
   "source": [
    "本案例已同步上线[GitHub仓](https://github.com/mindspore-courses/orange-pi-mindspore/tree/master/Online/inference/02-ResNet50)，更多案例开发亦可参考该仓库\n",
    "\n",
    "本案例运行所需环境：\n",
    "\n",
    "- 硬件： 香橙派AIpro 8G 8T开发板\n",
    "- 镜像： 香橙派官网ubuntu镜像\n",
    "- CANN：8.1.RC1\n",
    "- MindSpore： 2.6.0"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
